package com.wicket.okrcalc.biz.service.impl;

import cn.hutool.core.bean.BeanUtil;
import com.wicket.okrcalc.biz.service.dto.req.*;
import com.wicket.okrcalc.biz.service.dto.res.*;
import org.apache.skywalking.apm.toolkit.trace.Tag;
import org.apache.skywalking.apm.toolkit.trace.Tags;
import org.apache.skywalking.apm.toolkit.trace.Trace;
import com.wicket.okrcalc.common.util.CommonFunctionHelper;
import com.wicket.okrcalc.common.util.RedisUtil;
import com.wicket.okrcalc.common.exception.BizException;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;

import java.util.List;
import java.util.stream.Collectors;
import com.wicket.okrcalc.base.service.MOmsStandardDataResultService;
import com.wicket.okrcalc.dal.po.mbg.OmsStandardDataResult;
import com.wicket.okrcalc.common.exception.Assert;
import com.wicket.okrcalc.biz.service.nb.NbSystemTestDomain;
import com.wicket.okrcalc.base.service.dto.req.QuerySingleEvaObjTarCycStaDataListReq;
import java.util.ArrayList;
import com.wicket.okrcalc.base.service.dto.req.QueryMultiEvaObjTarCycStaDataListReq;
import com.wicket.okrcalc.base.service.dto.req.QueryEvaObjTarCycStaDataListReq;
import com.wicket.okrcalc.base.service.dto.req.QuerySingleEvaObjTarCycStaDataDetailReq;
import cn.hutool.core.collection.CollectionUtil;
import com.wicket.okrapp.integration.dto.ObtainTargetBelongCycleComRespDto;
import com.wicket.okrapp.integration.dto.ObtainTargetBelongCycleComReqDto;
import java.util.Collections;
import com.wicket.okrapp.integration.FwAppTargetCalcClient;
import com.wicket.okrcalc.biz.service.StandardDataService;
import com.wicket.okrcalc.biz.service.TargetCalcService;
import com.wicket.okrapp.integration.dto.QueryTargetBeCycleDetailComRespDto;
import com.wicket.okrapp.integration.dto.QueryTargetBeCycleDetailComReqDto;
import com.wicket.okrapp.integration.dto.QueryLastExecCycleAndTargetCycleDetailComRespDto;
import com.wicket.okrapp.integration.dto.QueryLastExecCycleAndTargetCycleDetailComReqDto;
import com.wicket.okrapp.integration.FwAppSystemTestDomainClient;
import com.wicket.okrapp.integration.FwAppExecuteCycleClient;
import com.wicket.okrcalc.base.service.dto.req.QueryRepairStandardDataListReq;
import com.wicket.okrcalc.biz.service.dto.common.StandardDataDto;
import com.wicket.okrapp.integration.dto.QueryVirtualOrgMemberDetailComRespDto;
import com.wicket.okrapp.integration.dto.QueryVirtualOrgMemberDetailComReqDto;
import com.wicket.okrapp.integration.FwAppVirtualOrgClient;
import com.wicket.okrapp.integration.dto.AnalysisCommonDataComRespDto;
import com.wicket.okrapp.integration.dto.AnalysisCommonDataComReqDto;
import com.wicket.okrcomponent.integration.dto.ImplementDebugBusinessDataRedisComRespDto;
import com.wicket.okrcomponent.integration.dto.ImplementDebugBusinessDataRedisComReqDto;
import com.wicket.okrcomponent.integration.FwCompBusinessAtomClient;
import com.wicket.okrcalc.base.service.dto.req.QueryStandardDataDetailReq;
import com.wicket.okrapp.integration.dto.QueryTargetObjDetailComRespDto;
import com.wicket.okrapp.integration.dto.QueryTargetObjDetailComReqDto;
import com.wicket.okrapp.integration.FwAppIndexSystemClient;
import com.wicket.okrapp.integration.dto.QueryCurAndAncestorTargetAttributionCycleListComRespDto;
import com.wicket.okrapp.integration.dto.QueryCurAndAncestorTargetAttributionCycleListComReqDto;
import com.wicket.okrapp.integration.dto.TargetBelongCycleDto;

/**
 * @author ：
 * @date ：
 *
 *
 * @version 1.0
 */
@Service
public class SystemTestDomainServiceImpl implements com.wicket.okrcalc.biz.service.SystemTestDomainService {
    @Resource
    private RedisUtil redisUtil;
@Resource
  private MOmsStandardDataResultService mOmsStandardDataResultService;
//@Resource
 //private MCustomFieldsService mCustomFieldsService;
@Resource
  private NbSystemTestDomain nbSystemTestDomain;
//@Resource
 //private undefinedService undefinedService;
@Resource
  private FwAppTargetCalcClient fwAppTargetCalcClient;
@Resource
  private StandardDataService standardDataService;
@Resource
  private TargetCalcService targetCalcService;
@Resource
  private FwAppSystemTestDomainClient fwAppSystemTestDomainClient;
@Resource
  private FwAppExecuteCycleClient fwAppExecuteCycleClient;
@Resource
  private FwAppVirtualOrgClient fwAppVirtualOrgClient;
@Resource
  private FwCompBusinessAtomClient fwCompBusinessAtomClient;
@Resource
  private FwAppIndexSystemClient fwAppIndexSystemClient;
//@Resource
 //private MOmsTargetAttributionCycleService mOmsTargetAttributionCycleService;
/**
   * D4-构造单条被评对象目标周期标准数据验证数据(公共)[4256]
   * gen by moon at 9/12/2022, 6:25:55 PM
   */
  @Trace(operationName = "D4-构造单条被评对象目标周期标准数据验证数据(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public BuildSingleEvaObjTarCycStaDataComRespDto buildSingleEvaObjTarCycStaDataCom(BuildSingleEvaObjTarCycStaDataComReqDto reqDto){
    
      
      String string_1 =null;
//步骤0: M-构造被评对象目标周期标准数据验证数据 - buildEvaObjTarCycStaData
     String string = null;
    OmsStandardDataResult omsStandardDataResult=new OmsStandardDataResult();
  if(reqDto!=null){
      omsStandardDataResult.setDataResult(reqDto.getDataResult());//sourceId:266157_1
omsStandardDataResult.setResultType(reqDto.getResultType());//sourceId:276913_1
omsStandardDataResult.setParentDataResultId(reqDto.getParentDataResultId());//sourceId:266158_1
omsStandardDataResult.setParentDataResult(reqDto.getParentDataResult());//sourceId:266159_1
omsStandardDataResult.setUnit(reqDto.getUnit());//sourceId:266160_1
omsStandardDataResult.setIsNewData(reqDto.getIsNewData());//sourceId:276914_1
omsStandardDataResult.setPeriodId(reqDto.getPeriodId());//sourceId:266161_1
omsStandardDataResult.setCycleStartTime(reqDto.getCycleStartTime());//sourceId:266162_1
omsStandardDataResult.setCycleEndTime(reqDto.getCycleEndTime());//sourceId:266163_1
omsStandardDataResult.setCycleTypeCode(reqDto.getCycleTypeCode());//sourceId:266164_1
omsStandardDataResult.setCycleTypeInstanceCode(reqDto.getCycleTypeInstanceCode());//sourceId:266165_1
omsStandardDataResult.setDataType(reqDto.getDataType());//sourceId:266166_1
omsStandardDataResult.setTableTypeCode(reqDto.getTableTypeCode());//sourceId:266167_1
omsStandardDataResult.setEntityId(reqDto.getEntityId());//sourceId:266168_1
omsStandardDataResult.setFromContentTableTypeCode(reqDto.getFromContentTableTypeCode());//sourceId:266169_1
omsStandardDataResult.setFromContentEntityId(reqDto.getFromContentEntityId());//sourceId:266170_1
omsStandardDataResult.setBelongToContentTypeCode(reqDto.getBelongToContentTypeCode());//sourceId:301686_1
omsStandardDataResult.setBelongToContentId(reqDto.getBelongToContentId());//sourceId:301687_1
omsStandardDataResult.setPersonLiableObjId(reqDto.getPersonLiableObjId());//sourceId:266171_1
omsStandardDataResult.setBizRoleObjId(reqDto.getBizRoleObjId());//sourceId:266172_1
omsStandardDataResult.setBizRoleObjCode(reqDto.getBizRoleObjCode());//sourceId:266173_1
omsStandardDataResult.setPersonLiableTypeCode(reqDto.getPersonLiableTypeCode());//sourceId:266174_1
omsStandardDataResult.setBizRoleObjName(reqDto.getBizRoleObjName());//sourceId:266175_1
    }
  
    /*M-构造被评对象目标周期标准数据验证数据[4255]   */
    Assert.isNull(omsStandardDataResult.getDataResult(),"D4-构造单条被评对象目标周期标准数据验证数据(公共)-M-构造被评对象目标周期标准数据验证数据-数据值结果不能为空",false);
Assert.isNull(omsStandardDataResult.getResultType(),"D4-构造单条被评对象目标周期标准数据验证数据(公共)-M-构造被评对象目标周期标准数据验证数据-结果产生类型 不能为空",false);
Assert.isNull(omsStandardDataResult.getIsNewData(),"D4-构造单条被评对象目标周期标准数据验证数据(公共)-M-构造被评对象目标周期标准数据验证数据-是否最新数据不能为空",false);
Assert.isNull(omsStandardDataResult.getPeriodId(),"D4-构造单条被评对象目标周期标准数据验证数据(公共)-M-构造被评对象目标周期标准数据验证数据-周期ID不能为空",false);
Assert.isNull(omsStandardDataResult.getCycleStartTime(),"D4-构造单条被评对象目标周期标准数据验证数据(公共)-M-构造被评对象目标周期标准数据验证数据-周期开始时间不能为空",false);
Assert.isNull(omsStandardDataResult.getCycleEndTime(),"D4-构造单条被评对象目标周期标准数据验证数据(公共)-M-构造被评对象目标周期标准数据验证数据-周期结束时间不能为空",false);
Assert.isNull(omsStandardDataResult.getCycleTypeCode(),"D4-构造单条被评对象目标周期标准数据验证数据(公共)-M-构造被评对象目标周期标准数据验证数据-周期类型标识不能为空",false);
Assert.isNull(omsStandardDataResult.getDataType(),"D4-构造单条被评对象目标周期标准数据验证数据(公共)-M-构造被评对象目标周期标准数据验证数据-数据类型编码不能为空",false);
Assert.isNull(omsStandardDataResult.getTableTypeCode(),"D4-构造单条被评对象目标周期标准数据验证数据(公共)-M-构造被评对象目标周期标准数据验证数据-归属内容表类型编码不能为空",false);
Assert.isNull(omsStandardDataResult.getEntityId(),"D4-构造单条被评对象目标周期标准数据验证数据(公共)-M-构造被评对象目标周期标准数据验证数据-归属内容表主键ID不能为空",false);
Assert.isNull(omsStandardDataResult.getPersonLiableObjId(),"D4-构造单条被评对象目标周期标准数据验证数据(公共)-M-构造被评对象目标周期标准数据验证数据-填报评价责任人对象ID不能为空",false);
Assert.isNull(omsStandardDataResult.getBizRoleObjId(),"D4-构造单条被评对象目标周期标准数据验证数据(公共)-M-构造被评对象目标周期标准数据验证数据-填报评价责任人业务角色对象ID不能为空",false);
Assert.isNull(omsStandardDataResult.getBizRoleObjCode(),"D4-构造单条被评对象目标周期标准数据验证数据(公共)-M-构造被评对象目标周期标准数据验证数据-填报评价责任人业务角色标识不能为空",false);
Assert.isNull(omsStandardDataResult.getPersonLiableTypeCode(),"D4-构造单条被评对象目标周期标准数据验证数据(公共)-M-构造被评对象目标周期标准数据验证数据-填报评价责任人身份类型编码不能为空",false);
Assert.isNull(omsStandardDataResult.getBizRoleObjName(),"D4-构造单条被评对象目标周期标准数据验证数据(公共)-M-构造被评对象目标周期标准数据验证数据-填报评价责任人业务角色对象名称不能为空",false);
      string = mOmsStandardDataResultService.buildEvaObjTarCycStaData(omsStandardDataResult);
      
      
      string_1 = string;
    
BuildSingleEvaObjTarCycStaDataComRespDto retData = new BuildSingleEvaObjTarCycStaDataComRespDto();
  if(string_1!=null){
      retData.setDataResultId(string_1);//sourceId:276067_1
    }
  

  
  
return retData;
  }
/**
   * D4-构造多条被评对象目标周期标准数据验证数据(公共)[4305]
   * gen by moon at 9/12/2022, 6:26:06 PM
   */
  @Trace(operationName = "D4-构造多条被评对象目标周期标准数据验证数据(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public BuildMultiEvaObjTarCycStaDataComRespDto buildMultiEvaObjTarCycStaDataCom(BuildMultiEvaObjTarCycStaDataComReqDto reqDto){
    
      
      //步骤0: M4-执行接收字段（特殊方法） - implementReceiveField
     //ModelCode: receptionService
        ImplementReceiveFieldRespDto receptionServiceRes = null;
    ImplementReceiveFieldReqDto receptionServiceReq=new ImplementReceiveFieldReqDto();
  if(reqDto!=null){
      receptionServiceReq.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//sourceId:279771_1
receptionServiceReq.setTargetCycleContentId(reqDto.getTargetCycleContentId());//sourceId:301692_1
receptionServiceReq.setPersonLiableObjId(reqDto.getPersonLiableObjId());//sourceId:279722_1
receptionServiceReq.setTargetCycleContentTypeCode(reqDto.getTargetCycleContentTypeCode());//sourceId:301693_1
receptionServiceReq.setBizRoleObjId(reqDto.getBizRoleObjId());//sourceId:279723_1
receptionServiceReq.setBizRoleObjName(reqDto.getBizRoleObjName());//sourceId:279724_1
receptionServiceReq.setPersonLiableTypeCode(reqDto.getPersonLiableTypeCode());//sourceId:279725_1
receptionServiceReq.setBizRoleObjCode(reqDto.getBizRoleObjCode());//sourceId:279726_1
receptionServiceReq.setActualValue(reqDto.getActualValue());//sourceId:279721_1
receptionServiceReq.setActualValueUnit(reqDto.getActualValueUnit());//sourceId:279720_1
receptionServiceReq.setCycleId(reqDto.getCycleId());//sourceId:279772_1
receptionServiceReq.setCycleTypeCode(reqDto.getCycleTypeCode());//sourceId:279773_1
receptionServiceReq.setCycleTypeInstanceCode(reqDto.getCycleTypeInstanceCode());//sourceId:279774_1
receptionServiceReq.setCycleStageDataId(reqDto.getCycleStageDataId());//sourceId:279775_1
receptionServiceReq.setProgressValue(reqDto.getProgressValue());//sourceId:279741_1
receptionServiceReq.setCycleStartTime(reqDto.getCycleStartTime());//sourceId:279776_1
receptionServiceReq.setCycleEndTime(reqDto.getCycleEndTime());//sourceId:279777_1
receptionServiceReq.setProgressValueUnit(reqDto.getProgressValueUnit());//sourceId:279742_1
receptionServiceReq.setReach(reqDto.getReach());//sourceId:279745_1
receptionServiceReq.setActualFromLastTimeRatio(reqDto.getActualFromLastTimeRatio());//sourceId:279746_1
receptionServiceReq.setReachUnit(reqDto.getReachUnit());//sourceId:279747_1
receptionServiceReq.setActualFromLastTimeRatioUnit(reqDto.getActualFromLastTimeRatioUnit());//sourceId:279748_1
receptionServiceReq.setRealTimeScore(reqDto.getRealTimeScore());//sourceId:279750_1
receptionServiceReq.setRealTimeScoreUnit(reqDto.getRealTimeScoreUnit());//sourceId:279751_1
receptionServiceReq.setProgressFromLastRatio(reqDto.getProgressFromLastRatio());//sourceId:279743_1
receptionServiceReq.setProgressFromLastRatioUnit(reqDto.getProgressFromLastRatioUnit());//sourceId:279744_1
    }
  
    /*M4-执行接收字段（特殊方法）[2950]  用于特殊方法接收上游入参。 */
    
      receptionServiceRes = nbSystemTestDomain.implementReceiveField(receptionServiceReq);
      
      
      
    
//步骤1: D4-构造单条被评对象目标周期标准数据验证数据(公共) - buildSingleEvaObjTarCycStaDataCom
     BuildSingleEvaObjTarCycStaDataComRespDto buildSingleEvaObjTarCycStaDataComRespDto = null;
    BuildSingleEvaObjTarCycStaDataComReqDto buildSingleEvaObjTarCycStaDataComReqDto=new BuildSingleEvaObjTarCycStaDataComReqDto();
  buildSingleEvaObjTarCycStaDataComReqDto.setDataType("ACTUAL_VALUE");//sourceId:279436_1
buildSingleEvaObjTarCycStaDataComReqDto.setResultType("MANUAL_INPUT");//sourceId:279446_1
buildSingleEvaObjTarCycStaDataComReqDto.setIsNewData("TRUE");//sourceId:279447_1
buildSingleEvaObjTarCycStaDataComReqDto.setTableTypeCode("OMS_EVALUATION_OBJECT_TARGET_CYCLE");//sourceId:279437_1
buildSingleEvaObjTarCycStaDataComReqDto.setFromContentTableTypeCode("OMS_TSPE_CYCLE_STAGE_DATA");//sourceId:279439_1
if(reqDto!=null){
      buildSingleEvaObjTarCycStaDataComReqDto.setDataResult(reqDto.getActualValue());//sourceId:279427_1
buildSingleEvaObjTarCycStaDataComReqDto.setUnit(reqDto.getActualValueUnit());//sourceId:279430_1
buildSingleEvaObjTarCycStaDataComReqDto.setPeriodId(reqDto.getCycleId());//sourceId:279431_1
buildSingleEvaObjTarCycStaDataComReqDto.setCycleStartTime(reqDto.getCycleStartTime());//sourceId:279432_1
buildSingleEvaObjTarCycStaDataComReqDto.setCycleEndTime(reqDto.getCycleEndTime());//sourceId:279433_1
buildSingleEvaObjTarCycStaDataComReqDto.setCycleTypeCode(reqDto.getCycleTypeCode());//sourceId:279434_1
buildSingleEvaObjTarCycStaDataComReqDto.setCycleTypeInstanceCode(reqDto.getCycleTypeInstanceCode());//sourceId:280113_1
buildSingleEvaObjTarCycStaDataComReqDto.setEntityId(reqDto.getEvaObjTargetCycleId());//sourceId:279438_1
buildSingleEvaObjTarCycStaDataComReqDto.setFromContentEntityId(reqDto.getCycleStageDataId());//sourceId:279440_1
buildSingleEvaObjTarCycStaDataComReqDto.setBelongToContentTypeCode(reqDto.getTargetCycleContentTypeCode());//sourceId:301706_1
buildSingleEvaObjTarCycStaDataComReqDto.setBelongToContentId(reqDto.getTargetCycleContentId());//sourceId:301707_1
buildSingleEvaObjTarCycStaDataComReqDto.setPersonLiableObjId(reqDto.getPersonLiableObjId());//sourceId:279441_1
buildSingleEvaObjTarCycStaDataComReqDto.setBizRoleObjId(reqDto.getBizRoleObjId());//sourceId:279442_1
buildSingleEvaObjTarCycStaDataComReqDto.setBizRoleObjCode(reqDto.getBizRoleObjCode());//sourceId:279443_1
buildSingleEvaObjTarCycStaDataComReqDto.setPersonLiableTypeCode(reqDto.getPersonLiableTypeCode());//sourceId:279444_1
buildSingleEvaObjTarCycStaDataComReqDto.setBizRoleObjName(reqDto.getBizRoleObjName());//sourceId:279445_1
    }
  
    /*D4-构造单条被评对象目标周期标准数据验证数据(实际值)[4256]   */
    Assert.isNull(buildSingleEvaObjTarCycStaDataComReqDto.getDataType(),"D4-构造多条被评对象目标周期标准数据验证数据(公共)-D4-构造单条被评对象目标周期标准数据验证数据(实际值)-数据类型编码不能为空",false);
Assert.isNull(buildSingleEvaObjTarCycStaDataComReqDto.getResultType(),"D4-构造多条被评对象目标周期标准数据验证数据(公共)-D4-构造单条被评对象目标周期标准数据验证数据(实际值)-结果产生类型 不能为空",false);
Assert.isNull(buildSingleEvaObjTarCycStaDataComReqDto.getDataResult(),"D4-构造多条被评对象目标周期标准数据验证数据(公共)-D4-构造单条被评对象目标周期标准数据验证数据(实际值)-数据值结果不能为空",false);
Assert.isNull(buildSingleEvaObjTarCycStaDataComReqDto.getPeriodId(),"D4-构造多条被评对象目标周期标准数据验证数据(公共)-D4-构造单条被评对象目标周期标准数据验证数据(实际值)-周期ID不能为空",false);
Assert.isNull(buildSingleEvaObjTarCycStaDataComReqDto.getCycleStartTime(),"D4-构造多条被评对象目标周期标准数据验证数据(公共)-D4-构造单条被评对象目标周期标准数据验证数据(实际值)-周期开始时间不能为空",false);
Assert.isNull(buildSingleEvaObjTarCycStaDataComReqDto.getCycleEndTime(),"D4-构造多条被评对象目标周期标准数据验证数据(公共)-D4-构造单条被评对象目标周期标准数据验证数据(实际值)-周期结束时间不能为空",false);
Assert.isNull(buildSingleEvaObjTarCycStaDataComReqDto.getCycleTypeCode(),"D4-构造多条被评对象目标周期标准数据验证数据(公共)-D4-构造单条被评对象目标周期标准数据验证数据(实际值)-周期类型标识不能为空",false);
Assert.isNull(buildSingleEvaObjTarCycStaDataComReqDto.getIsNewData(),"D4-构造多条被评对象目标周期标准数据验证数据(公共)-D4-构造单条被评对象目标周期标准数据验证数据(实际值)-是否最新数据不能为空",false);
Assert.isNull(buildSingleEvaObjTarCycStaDataComReqDto.getTableTypeCode(),"D4-构造多条被评对象目标周期标准数据验证数据(公共)-D4-构造单条被评对象目标周期标准数据验证数据(实际值)-归属内容表类型编码不能为空",false);
Assert.isNull(buildSingleEvaObjTarCycStaDataComReqDto.getEntityId(),"D4-构造多条被评对象目标周期标准数据验证数据(公共)-D4-构造单条被评对象目标周期标准数据验证数据(实际值)-归属内容表主键ID不能为空",false);
Assert.isNull(buildSingleEvaObjTarCycStaDataComReqDto.getFromContentTableTypeCode(),"D4-构造多条被评对象目标周期标准数据验证数据(公共)-D4-构造单条被评对象目标周期标准数据验证数据(实际值)-来自内容表类型编码不能为空",false);
Assert.isNull(buildSingleEvaObjTarCycStaDataComReqDto.getPersonLiableObjId(),"D4-构造多条被评对象目标周期标准数据验证数据(公共)-D4-构造单条被评对象目标周期标准数据验证数据(实际值)-填报评价责任人对象ID不能为空",false);
Assert.isNull(buildSingleEvaObjTarCycStaDataComReqDto.getBizRoleObjId(),"D4-构造多条被评对象目标周期标准数据验证数据(公共)-D4-构造单条被评对象目标周期标准数据验证数据(实际值)-填报评价责任人业务角色对象ID不能为空",false);
Assert.isNull(buildSingleEvaObjTarCycStaDataComReqDto.getBizRoleObjCode(),"D4-构造多条被评对象目标周期标准数据验证数据(公共)-D4-构造单条被评对象目标周期标准数据验证数据(实际值)-填报评价责任人业务角色标识不能为空",false);
Assert.isNull(buildSingleEvaObjTarCycStaDataComReqDto.getPersonLiableTypeCode(),"D4-构造多条被评对象目标周期标准数据验证数据(公共)-D4-构造单条被评对象目标周期标准数据验证数据(实际值)-填报评价责任人身份类型编码不能为空",false);
Assert.isNull(buildSingleEvaObjTarCycStaDataComReqDto.getBizRoleObjName(),"D4-构造多条被评对象目标周期标准数据验证数据(公共)-D4-构造单条被评对象目标周期标准数据验证数据(实际值)-填报评价责任人业务角色对象名称不能为空",false);
      buildSingleEvaObjTarCycStaDataComRespDto = buildSingleEvaObjTarCycStaDataCom(buildSingleEvaObjTarCycStaDataComReqDto);
      
      
      
    
//步骤2: D4-构造单条被评对象目标周期标准数据验证数据(公共) - buildSingleEvaObjTarCycStaDataCom
     BuildSingleEvaObjTarCycStaDataComRespDto buildSingleEvaObjTarCycStaDataComRespDto_2 = null;
    BuildSingleEvaObjTarCycStaDataComReqDto buildSingleEvaObjTarCycStaDataComReqDto_1=new BuildSingleEvaObjTarCycStaDataComReqDto();
  buildSingleEvaObjTarCycStaDataComReqDto_1.setDataType("PROGRESS_VALUE");//sourceId:279458_1
buildSingleEvaObjTarCycStaDataComReqDto_1.setResultType("MANUAL_INPUT");//sourceId:279468_1
buildSingleEvaObjTarCycStaDataComReqDto_1.setIsNewData("TRUE");//sourceId:279469_1
buildSingleEvaObjTarCycStaDataComReqDto_1.setTableTypeCode("OMS_EVALUATION_OBJECT_TARGET_CYCLE");//sourceId:279459_1
buildSingleEvaObjTarCycStaDataComReqDto_1.setFromContentTableTypeCode("OMS_TSPE_CYCLE_STAGE_DATA");//sourceId:279461_1
if(reqDto!=null){
      buildSingleEvaObjTarCycStaDataComReqDto_1.setDataResult(reqDto.getProgressValue());//sourceId:279449_1
buildSingleEvaObjTarCycStaDataComReqDto_1.setUnit(reqDto.getProgressValueUnit());//sourceId:279452_1
buildSingleEvaObjTarCycStaDataComReqDto_1.setPeriodId(reqDto.getCycleId());//sourceId:279453_1
buildSingleEvaObjTarCycStaDataComReqDto_1.setCycleStartTime(reqDto.getCycleStartTime());//sourceId:279454_1
buildSingleEvaObjTarCycStaDataComReqDto_1.setCycleEndTime(reqDto.getCycleEndTime());//sourceId:279455_1
buildSingleEvaObjTarCycStaDataComReqDto_1.setCycleTypeCode(reqDto.getCycleTypeCode());//sourceId:279456_1
buildSingleEvaObjTarCycStaDataComReqDto_1.setCycleTypeInstanceCode(reqDto.getCycleTypeInstanceCode());//sourceId:280116_1
buildSingleEvaObjTarCycStaDataComReqDto_1.setEntityId(reqDto.getEvaObjTargetCycleId());//sourceId:279460_1
buildSingleEvaObjTarCycStaDataComReqDto_1.setFromContentEntityId(reqDto.getCycleStageDataId());//sourceId:279462_1
buildSingleEvaObjTarCycStaDataComReqDto_1.setBelongToContentTypeCode(reqDto.getTargetCycleContentTypeCode());//sourceId:301690_1
buildSingleEvaObjTarCycStaDataComReqDto_1.setBelongToContentId(reqDto.getTargetCycleContentId());//sourceId:301691_1
buildSingleEvaObjTarCycStaDataComReqDto_1.setPersonLiableObjId(reqDto.getPersonLiableObjId());//sourceId:279463_1
buildSingleEvaObjTarCycStaDataComReqDto_1.setBizRoleObjId(reqDto.getBizRoleObjId());//sourceId:279464_1
buildSingleEvaObjTarCycStaDataComReqDto_1.setBizRoleObjCode(reqDto.getBizRoleObjCode());//sourceId:279465_1
buildSingleEvaObjTarCycStaDataComReqDto_1.setPersonLiableTypeCode(reqDto.getPersonLiableTypeCode());//sourceId:279466_1
buildSingleEvaObjTarCycStaDataComReqDto_1.setBizRoleObjName(reqDto.getBizRoleObjName());//sourceId:279467_1
    }
  
    /*D4-构造单条被评对象目标周期标准数据验证数据(进度值)[4256]   */
    Assert.isNull(buildSingleEvaObjTarCycStaDataComReqDto_1.getDataType(),"D4-构造多条被评对象目标周期标准数据验证数据(公共)-D4-构造单条被评对象目标周期标准数据验证数据(进度值)-数据类型编码不能为空",false);
Assert.isNull(buildSingleEvaObjTarCycStaDataComReqDto_1.getResultType(),"D4-构造多条被评对象目标周期标准数据验证数据(公共)-D4-构造单条被评对象目标周期标准数据验证数据(进度值)-结果产生类型 不能为空",false);
Assert.isNull(buildSingleEvaObjTarCycStaDataComReqDto_1.getDataResult(),"D4-构造多条被评对象目标周期标准数据验证数据(公共)-D4-构造单条被评对象目标周期标准数据验证数据(进度值)-数据值结果不能为空",false);
Assert.isNull(buildSingleEvaObjTarCycStaDataComReqDto_1.getPeriodId(),"D4-构造多条被评对象目标周期标准数据验证数据(公共)-D4-构造单条被评对象目标周期标准数据验证数据(进度值)-周期ID不能为空",false);
Assert.isNull(buildSingleEvaObjTarCycStaDataComReqDto_1.getCycleStartTime(),"D4-构造多条被评对象目标周期标准数据验证数据(公共)-D4-构造单条被评对象目标周期标准数据验证数据(进度值)-周期开始时间不能为空",false);
Assert.isNull(buildSingleEvaObjTarCycStaDataComReqDto_1.getCycleEndTime(),"D4-构造多条被评对象目标周期标准数据验证数据(公共)-D4-构造单条被评对象目标周期标准数据验证数据(进度值)-周期结束时间不能为空",false);
Assert.isNull(buildSingleEvaObjTarCycStaDataComReqDto_1.getCycleTypeCode(),"D4-构造多条被评对象目标周期标准数据验证数据(公共)-D4-构造单条被评对象目标周期标准数据验证数据(进度值)-周期类型标识不能为空",false);
Assert.isNull(buildSingleEvaObjTarCycStaDataComReqDto_1.getIsNewData(),"D4-构造多条被评对象目标周期标准数据验证数据(公共)-D4-构造单条被评对象目标周期标准数据验证数据(进度值)-是否最新数据不能为空",false);
Assert.isNull(buildSingleEvaObjTarCycStaDataComReqDto_1.getTableTypeCode(),"D4-构造多条被评对象目标周期标准数据验证数据(公共)-D4-构造单条被评对象目标周期标准数据验证数据(进度值)-归属内容表类型编码不能为空",false);
Assert.isNull(buildSingleEvaObjTarCycStaDataComReqDto_1.getEntityId(),"D4-构造多条被评对象目标周期标准数据验证数据(公共)-D4-构造单条被评对象目标周期标准数据验证数据(进度值)-归属内容表主键ID不能为空",false);
Assert.isNull(buildSingleEvaObjTarCycStaDataComReqDto_1.getPersonLiableObjId(),"D4-构造多条被评对象目标周期标准数据验证数据(公共)-D4-构造单条被评对象目标周期标准数据验证数据(进度值)-填报评价责任人对象ID不能为空",false);
Assert.isNull(buildSingleEvaObjTarCycStaDataComReqDto_1.getBizRoleObjId(),"D4-构造多条被评对象目标周期标准数据验证数据(公共)-D4-构造单条被评对象目标周期标准数据验证数据(进度值)-填报评价责任人业务角色对象ID不能为空",false);
Assert.isNull(buildSingleEvaObjTarCycStaDataComReqDto_1.getBizRoleObjCode(),"D4-构造多条被评对象目标周期标准数据验证数据(公共)-D4-构造单条被评对象目标周期标准数据验证数据(进度值)-填报评价责任人业务角色标识不能为空",false);
Assert.isNull(buildSingleEvaObjTarCycStaDataComReqDto_1.getPersonLiableTypeCode(),"D4-构造多条被评对象目标周期标准数据验证数据(公共)-D4-构造单条被评对象目标周期标准数据验证数据(进度值)-填报评价责任人身份类型编码不能为空",false);
Assert.isNull(buildSingleEvaObjTarCycStaDataComReqDto_1.getBizRoleObjName(),"D4-构造多条被评对象目标周期标准数据验证数据(公共)-D4-构造单条被评对象目标周期标准数据验证数据(进度值)-填报评价责任人业务角色对象名称不能为空",false);
      buildSingleEvaObjTarCycStaDataComRespDto_2 = buildSingleEvaObjTarCycStaDataCom(buildSingleEvaObjTarCycStaDataComReqDto_1);
      
      
      
    
//步骤3: D4-构造单条被评对象目标周期标准数据验证数据(公共) - buildSingleEvaObjTarCycStaDataCom
     BuildSingleEvaObjTarCycStaDataComRespDto buildSingleEvaObjTarCycStaDataComRespDto_4 = null;
    BuildSingleEvaObjTarCycStaDataComReqDto buildSingleEvaObjTarCycStaDataComReqDto_2=new BuildSingleEvaObjTarCycStaDataComReqDto();
  buildSingleEvaObjTarCycStaDataComReqDto_2.setDataType("PROGRESS_FROM_LAST_RATIO");//sourceId:279480_1
buildSingleEvaObjTarCycStaDataComReqDto_2.setResultType("SYSTEM_AUTO_COUNT");//sourceId:279490_1
buildSingleEvaObjTarCycStaDataComReqDto_2.setIsNewData("TRUE");//sourceId:279491_1
buildSingleEvaObjTarCycStaDataComReqDto_2.setTableTypeCode("OMS_EVALUATION_OBJECT_TARGET_CYCLE");//sourceId:279481_1
buildSingleEvaObjTarCycStaDataComReqDto_2.setFromContentTableTypeCode("OMS_TSPE_CYCLE_STAGE_DATA");//sourceId:279483_1
if(reqDto!=null){
      buildSingleEvaObjTarCycStaDataComReqDto_2.setDataResult(reqDto.getProgressFromLastRatio());//sourceId:279471_1
buildSingleEvaObjTarCycStaDataComReqDto_2.setUnit(reqDto.getProgressFromLastRatioUnit());//sourceId:279474_1
buildSingleEvaObjTarCycStaDataComReqDto_2.setPeriodId(reqDto.getCycleId());//sourceId:279475_1
buildSingleEvaObjTarCycStaDataComReqDto_2.setCycleStartTime(reqDto.getCycleStartTime());//sourceId:279476_1
buildSingleEvaObjTarCycStaDataComReqDto_2.setCycleEndTime(reqDto.getCycleEndTime());//sourceId:279477_1
buildSingleEvaObjTarCycStaDataComReqDto_2.setCycleTypeCode(reqDto.getCycleTypeCode());//sourceId:279478_1
buildSingleEvaObjTarCycStaDataComReqDto_2.setCycleTypeInstanceCode(reqDto.getCycleTypeInstanceCode());//sourceId:280124_1
buildSingleEvaObjTarCycStaDataComReqDto_2.setEntityId(reqDto.getEvaObjTargetCycleId());//sourceId:279482_1
buildSingleEvaObjTarCycStaDataComReqDto_2.setFromContentEntityId(reqDto.getCycleStageDataId());//sourceId:279484_1
buildSingleEvaObjTarCycStaDataComReqDto_2.setBelongToContentTypeCode(reqDto.getTargetCycleContentTypeCode());//sourceId:301698_1
buildSingleEvaObjTarCycStaDataComReqDto_2.setBelongToContentId(reqDto.getTargetCycleContentId());//sourceId:301699_1
buildSingleEvaObjTarCycStaDataComReqDto_2.setPersonLiableObjId(reqDto.getPersonLiableObjId());//sourceId:279485_1
buildSingleEvaObjTarCycStaDataComReqDto_2.setBizRoleObjId(reqDto.getBizRoleObjId());//sourceId:279486_1
buildSingleEvaObjTarCycStaDataComReqDto_2.setBizRoleObjCode(reqDto.getBizRoleObjCode());//sourceId:279487_1
buildSingleEvaObjTarCycStaDataComReqDto_2.setPersonLiableTypeCode(reqDto.getPersonLiableTypeCode());//sourceId:279488_1
buildSingleEvaObjTarCycStaDataComReqDto_2.setBizRoleObjName(reqDto.getBizRoleObjName());//sourceId:279489_1
    }
  
    /*D4-构造单条被评对象目标周期标准数据验证数据(进度较上次增降幅)[4256]   */
    Assert.isNull(buildSingleEvaObjTarCycStaDataComReqDto_2.getDataType(),"D4-构造多条被评对象目标周期标准数据验证数据(公共)-D4-构造单条被评对象目标周期标准数据验证数据(进度较上次增降幅)-数据类型编码不能为空",false);
Assert.isNull(buildSingleEvaObjTarCycStaDataComReqDto_2.getResultType(),"D4-构造多条被评对象目标周期标准数据验证数据(公共)-D4-构造单条被评对象目标周期标准数据验证数据(进度较上次增降幅)-结果产生类型 不能为空",false);
Assert.isNull(buildSingleEvaObjTarCycStaDataComReqDto_2.getDataResult(),"D4-构造多条被评对象目标周期标准数据验证数据(公共)-D4-构造单条被评对象目标周期标准数据验证数据(进度较上次增降幅)-数据值结果不能为空",false);
Assert.isNull(buildSingleEvaObjTarCycStaDataComReqDto_2.getPeriodId(),"D4-构造多条被评对象目标周期标准数据验证数据(公共)-D4-构造单条被评对象目标周期标准数据验证数据(进度较上次增降幅)-周期ID不能为空",false);
Assert.isNull(buildSingleEvaObjTarCycStaDataComReqDto_2.getCycleStartTime(),"D4-构造多条被评对象目标周期标准数据验证数据(公共)-D4-构造单条被评对象目标周期标准数据验证数据(进度较上次增降幅)-周期开始时间不能为空",false);
Assert.isNull(buildSingleEvaObjTarCycStaDataComReqDto_2.getCycleEndTime(),"D4-构造多条被评对象目标周期标准数据验证数据(公共)-D4-构造单条被评对象目标周期标准数据验证数据(进度较上次增降幅)-周期结束时间不能为空",false);
Assert.isNull(buildSingleEvaObjTarCycStaDataComReqDto_2.getCycleTypeCode(),"D4-构造多条被评对象目标周期标准数据验证数据(公共)-D4-构造单条被评对象目标周期标准数据验证数据(进度较上次增降幅)-周期类型标识不能为空",false);
Assert.isNull(buildSingleEvaObjTarCycStaDataComReqDto_2.getIsNewData(),"D4-构造多条被评对象目标周期标准数据验证数据(公共)-D4-构造单条被评对象目标周期标准数据验证数据(进度较上次增降幅)-是否最新数据不能为空",false);
Assert.isNull(buildSingleEvaObjTarCycStaDataComReqDto_2.getTableTypeCode(),"D4-构造多条被评对象目标周期标准数据验证数据(公共)-D4-构造单条被评对象目标周期标准数据验证数据(进度较上次增降幅)-归属内容表类型编码不能为空",false);
Assert.isNull(buildSingleEvaObjTarCycStaDataComReqDto_2.getEntityId(),"D4-构造多条被评对象目标周期标准数据验证数据(公共)-D4-构造单条被评对象目标周期标准数据验证数据(进度较上次增降幅)-归属内容表主键ID不能为空",false);
Assert.isNull(buildSingleEvaObjTarCycStaDataComReqDto_2.getPersonLiableObjId(),"D4-构造多条被评对象目标周期标准数据验证数据(公共)-D4-构造单条被评对象目标周期标准数据验证数据(进度较上次增降幅)-填报评价责任人对象ID不能为空",false);
Assert.isNull(buildSingleEvaObjTarCycStaDataComReqDto_2.getBizRoleObjId(),"D4-构造多条被评对象目标周期标准数据验证数据(公共)-D4-构造单条被评对象目标周期标准数据验证数据(进度较上次增降幅)-填报评价责任人业务角色对象ID不能为空",false);
Assert.isNull(buildSingleEvaObjTarCycStaDataComReqDto_2.getBizRoleObjCode(),"D4-构造多条被评对象目标周期标准数据验证数据(公共)-D4-构造单条被评对象目标周期标准数据验证数据(进度较上次增降幅)-填报评价责任人业务角色标识不能为空",false);
Assert.isNull(buildSingleEvaObjTarCycStaDataComReqDto_2.getPersonLiableTypeCode(),"D4-构造多条被评对象目标周期标准数据验证数据(公共)-D4-构造单条被评对象目标周期标准数据验证数据(进度较上次增降幅)-填报评价责任人身份类型编码不能为空",false);
Assert.isNull(buildSingleEvaObjTarCycStaDataComReqDto_2.getBizRoleObjName(),"D4-构造多条被评对象目标周期标准数据验证数据(公共)-D4-构造单条被评对象目标周期标准数据验证数据(进度较上次增降幅)-填报评价责任人业务角色对象名称不能为空",false);
      buildSingleEvaObjTarCycStaDataComRespDto_4 = buildSingleEvaObjTarCycStaDataCom(buildSingleEvaObjTarCycStaDataComReqDto_2);
      
      
      
    
//步骤4: D4-构造单条被评对象目标周期标准数据验证数据(公共) - buildSingleEvaObjTarCycStaDataCom
     BuildSingleEvaObjTarCycStaDataComRespDto buildSingleEvaObjTarCycStaDataComRespDto_6 = null;
    BuildSingleEvaObjTarCycStaDataComReqDto buildSingleEvaObjTarCycStaDataComReqDto_3=new BuildSingleEvaObjTarCycStaDataComReqDto();
  buildSingleEvaObjTarCycStaDataComReqDto_3.setDataType("REACH");//sourceId:279502_1
buildSingleEvaObjTarCycStaDataComReqDto_3.setResultType("SYSTEM_AUTO_COUNT");//sourceId:279512_1
buildSingleEvaObjTarCycStaDataComReqDto_3.setIsNewData("TRUE");//sourceId:279513_1
buildSingleEvaObjTarCycStaDataComReqDto_3.setTableTypeCode("OMS_EVALUATION_OBJECT_TARGET_CYCLE");//sourceId:279503_1
buildSingleEvaObjTarCycStaDataComReqDto_3.setFromContentTableTypeCode("OMS_TSPE_CYCLE_STAGE_DATA");//sourceId:279505_1
if(reqDto!=null){
      buildSingleEvaObjTarCycStaDataComReqDto_3.setDataResult(reqDto.getReach());//sourceId:279493_1
buildSingleEvaObjTarCycStaDataComReqDto_3.setUnit(reqDto.getReachUnit());//sourceId:279496_1
buildSingleEvaObjTarCycStaDataComReqDto_3.setPeriodId(reqDto.getCycleId());//sourceId:279497_1
buildSingleEvaObjTarCycStaDataComReqDto_3.setCycleStartTime(reqDto.getCycleStartTime());//sourceId:279498_1
buildSingleEvaObjTarCycStaDataComReqDto_3.setCycleEndTime(reqDto.getCycleEndTime());//sourceId:279499_1
buildSingleEvaObjTarCycStaDataComReqDto_3.setCycleTypeCode(reqDto.getCycleTypeCode());//sourceId:279500_1
buildSingleEvaObjTarCycStaDataComReqDto_3.setCycleTypeInstanceCode(reqDto.getCycleTypeInstanceCode());//sourceId:280125_1
buildSingleEvaObjTarCycStaDataComReqDto_3.setEntityId(reqDto.getEvaObjTargetCycleId());//sourceId:279504_1
buildSingleEvaObjTarCycStaDataComReqDto_3.setFromContentEntityId(reqDto.getCycleStageDataId());//sourceId:279506_1
buildSingleEvaObjTarCycStaDataComReqDto_3.setBelongToContentTypeCode(reqDto.getTargetCycleContentTypeCode());//sourceId:301700_1
buildSingleEvaObjTarCycStaDataComReqDto_3.setBelongToContentId(reqDto.getTargetCycleContentId());//sourceId:301701_1
buildSingleEvaObjTarCycStaDataComReqDto_3.setPersonLiableObjId(reqDto.getPersonLiableObjId());//sourceId:279507_1
buildSingleEvaObjTarCycStaDataComReqDto_3.setBizRoleObjId(reqDto.getBizRoleObjId());//sourceId:279508_1
buildSingleEvaObjTarCycStaDataComReqDto_3.setBizRoleObjCode(reqDto.getBizRoleObjCode());//sourceId:279509_1
buildSingleEvaObjTarCycStaDataComReqDto_3.setPersonLiableTypeCode(reqDto.getPersonLiableTypeCode());//sourceId:279510_1
buildSingleEvaObjTarCycStaDataComReqDto_3.setBizRoleObjName(reqDto.getBizRoleObjName());//sourceId:279511_1
    }
  
    /*D4-构造单条被评对象目标周期标准数据验证数据(达成度)[4256]   */
    Assert.isNull(buildSingleEvaObjTarCycStaDataComReqDto_3.getDataType(),"D4-构造多条被评对象目标周期标准数据验证数据(公共)-D4-构造单条被评对象目标周期标准数据验证数据(达成度)-数据类型编码不能为空",false);
Assert.isNull(buildSingleEvaObjTarCycStaDataComReqDto_3.getResultType(),"D4-构造多条被评对象目标周期标准数据验证数据(公共)-D4-构造单条被评对象目标周期标准数据验证数据(达成度)-结果产生类型 不能为空",false);
Assert.isNull(buildSingleEvaObjTarCycStaDataComReqDto_3.getDataResult(),"D4-构造多条被评对象目标周期标准数据验证数据(公共)-D4-构造单条被评对象目标周期标准数据验证数据(达成度)-数据值结果不能为空",false);
Assert.isNull(buildSingleEvaObjTarCycStaDataComReqDto_3.getPeriodId(),"D4-构造多条被评对象目标周期标准数据验证数据(公共)-D4-构造单条被评对象目标周期标准数据验证数据(达成度)-周期ID不能为空",false);
Assert.isNull(buildSingleEvaObjTarCycStaDataComReqDto_3.getCycleStartTime(),"D4-构造多条被评对象目标周期标准数据验证数据(公共)-D4-构造单条被评对象目标周期标准数据验证数据(达成度)-周期开始时间不能为空",false);
Assert.isNull(buildSingleEvaObjTarCycStaDataComReqDto_3.getCycleEndTime(),"D4-构造多条被评对象目标周期标准数据验证数据(公共)-D4-构造单条被评对象目标周期标准数据验证数据(达成度)-周期结束时间不能为空",false);
Assert.isNull(buildSingleEvaObjTarCycStaDataComReqDto_3.getCycleTypeCode(),"D4-构造多条被评对象目标周期标准数据验证数据(公共)-D4-构造单条被评对象目标周期标准数据验证数据(达成度)-周期类型标识不能为空",false);
Assert.isNull(buildSingleEvaObjTarCycStaDataComReqDto_3.getIsNewData(),"D4-构造多条被评对象目标周期标准数据验证数据(公共)-D4-构造单条被评对象目标周期标准数据验证数据(达成度)-是否最新数据不能为空",false);
Assert.isNull(buildSingleEvaObjTarCycStaDataComReqDto_3.getTableTypeCode(),"D4-构造多条被评对象目标周期标准数据验证数据(公共)-D4-构造单条被评对象目标周期标准数据验证数据(达成度)-归属内容表类型编码不能为空",false);
Assert.isNull(buildSingleEvaObjTarCycStaDataComReqDto_3.getEntityId(),"D4-构造多条被评对象目标周期标准数据验证数据(公共)-D4-构造单条被评对象目标周期标准数据验证数据(达成度)-归属内容表主键ID不能为空",false);
Assert.isNull(buildSingleEvaObjTarCycStaDataComReqDto_3.getPersonLiableObjId(),"D4-构造多条被评对象目标周期标准数据验证数据(公共)-D4-构造单条被评对象目标周期标准数据验证数据(达成度)-填报评价责任人对象ID不能为空",false);
Assert.isNull(buildSingleEvaObjTarCycStaDataComReqDto_3.getBizRoleObjId(),"D4-构造多条被评对象目标周期标准数据验证数据(公共)-D4-构造单条被评对象目标周期标准数据验证数据(达成度)-填报评价责任人业务角色对象ID不能为空",false);
Assert.isNull(buildSingleEvaObjTarCycStaDataComReqDto_3.getBizRoleObjCode(),"D4-构造多条被评对象目标周期标准数据验证数据(公共)-D4-构造单条被评对象目标周期标准数据验证数据(达成度)-填报评价责任人业务角色标识不能为空",false);
Assert.isNull(buildSingleEvaObjTarCycStaDataComReqDto_3.getPersonLiableTypeCode(),"D4-构造多条被评对象目标周期标准数据验证数据(公共)-D4-构造单条被评对象目标周期标准数据验证数据(达成度)-填报评价责任人身份类型编码不能为空",false);
Assert.isNull(buildSingleEvaObjTarCycStaDataComReqDto_3.getBizRoleObjName(),"D4-构造多条被评对象目标周期标准数据验证数据(公共)-D4-构造单条被评对象目标周期标准数据验证数据(达成度)-填报评价责任人业务角色对象名称不能为空",false);
      buildSingleEvaObjTarCycStaDataComRespDto_6 = buildSingleEvaObjTarCycStaDataCom(buildSingleEvaObjTarCycStaDataComReqDto_3);
      
      
      
    
//步骤5: D4-构造单条被评对象目标周期标准数据验证数据(公共) - buildSingleEvaObjTarCycStaDataCom
     BuildSingleEvaObjTarCycStaDataComRespDto buildSingleEvaObjTarCycStaDataComRespDto_8 = null;
    BuildSingleEvaObjTarCycStaDataComReqDto buildSingleEvaObjTarCycStaDataComReqDto_4=new BuildSingleEvaObjTarCycStaDataComReqDto();
  buildSingleEvaObjTarCycStaDataComReqDto_4.setDataType("ACTUAL_FROM_LAST_TIME_RATIO");//sourceId:279524_1
buildSingleEvaObjTarCycStaDataComReqDto_4.setResultType("SYSTEM_AUTO_COUNT");//sourceId:279534_1
buildSingleEvaObjTarCycStaDataComReqDto_4.setIsNewData("TRUE");//sourceId:279535_1
buildSingleEvaObjTarCycStaDataComReqDto_4.setTableTypeCode("OMS_EVALUATION_OBJECT_TARGET_CYCLE");//sourceId:279525_1
buildSingleEvaObjTarCycStaDataComReqDto_4.setFromContentTableTypeCode("OMS_TSPE_CYCLE_STAGE_DATA");//sourceId:279527_1
if(reqDto!=null){
      buildSingleEvaObjTarCycStaDataComReqDto_4.setDataResult(reqDto.getActualFromLastTimeRatio());//sourceId:279515_1
buildSingleEvaObjTarCycStaDataComReqDto_4.setUnit(reqDto.getActualFromLastTimeRatioUnit());//sourceId:279518_1
buildSingleEvaObjTarCycStaDataComReqDto_4.setPeriodId(reqDto.getCycleId());//sourceId:279519_1
buildSingleEvaObjTarCycStaDataComReqDto_4.setCycleStartTime(reqDto.getCycleStartTime());//sourceId:279520_1
buildSingleEvaObjTarCycStaDataComReqDto_4.setCycleEndTime(reqDto.getCycleEndTime());//sourceId:279521_1
buildSingleEvaObjTarCycStaDataComReqDto_4.setCycleTypeCode(reqDto.getCycleTypeCode());//sourceId:279522_1
buildSingleEvaObjTarCycStaDataComReqDto_4.setCycleTypeInstanceCode(reqDto.getCycleTypeInstanceCode());//sourceId:279523_1
buildSingleEvaObjTarCycStaDataComReqDto_4.setEntityId(reqDto.getEvaObjTargetCycleId());//sourceId:279526_1
buildSingleEvaObjTarCycStaDataComReqDto_4.setFromContentEntityId(reqDto.getCycleStageDataId());//sourceId:279528_1
buildSingleEvaObjTarCycStaDataComReqDto_4.setBelongToContentTypeCode(reqDto.getTargetCycleContentTypeCode());//sourceId:301702_1
buildSingleEvaObjTarCycStaDataComReqDto_4.setBelongToContentId(reqDto.getTargetCycleContentId());//sourceId:301703_1
buildSingleEvaObjTarCycStaDataComReqDto_4.setPersonLiableObjId(reqDto.getPersonLiableObjId());//sourceId:279529_1
buildSingleEvaObjTarCycStaDataComReqDto_4.setBizRoleObjId(reqDto.getBizRoleObjId());//sourceId:279530_1
buildSingleEvaObjTarCycStaDataComReqDto_4.setBizRoleObjCode(reqDto.getBizRoleObjCode());//sourceId:279531_1
buildSingleEvaObjTarCycStaDataComReqDto_4.setPersonLiableTypeCode(reqDto.getPersonLiableTypeCode());//sourceId:279532_1
buildSingleEvaObjTarCycStaDataComReqDto_4.setBizRoleObjName(reqDto.getBizRoleObjName());//sourceId:279533_1
    }
  
    /*D4-构造单条被评对象目标周期标准数据验证数据(达成度较上次增降幅)[4256]   */
    Assert.isNull(buildSingleEvaObjTarCycStaDataComReqDto_4.getDataType(),"D4-构造多条被评对象目标周期标准数据验证数据(公共)-D4-构造单条被评对象目标周期标准数据验证数据(达成度较上次增降幅)-数据类型编码不能为空",false);
Assert.isNull(buildSingleEvaObjTarCycStaDataComReqDto_4.getResultType(),"D4-构造多条被评对象目标周期标准数据验证数据(公共)-D4-构造单条被评对象目标周期标准数据验证数据(达成度较上次增降幅)-结果产生类型 不能为空",false);
Assert.isNull(buildSingleEvaObjTarCycStaDataComReqDto_4.getDataResult(),"D4-构造多条被评对象目标周期标准数据验证数据(公共)-D4-构造单条被评对象目标周期标准数据验证数据(达成度较上次增降幅)-数据值结果不能为空",false);
Assert.isNull(buildSingleEvaObjTarCycStaDataComReqDto_4.getPeriodId(),"D4-构造多条被评对象目标周期标准数据验证数据(公共)-D4-构造单条被评对象目标周期标准数据验证数据(达成度较上次增降幅)-周期ID不能为空",false);
Assert.isNull(buildSingleEvaObjTarCycStaDataComReqDto_4.getCycleStartTime(),"D4-构造多条被评对象目标周期标准数据验证数据(公共)-D4-构造单条被评对象目标周期标准数据验证数据(达成度较上次增降幅)-周期开始时间不能为空",false);
Assert.isNull(buildSingleEvaObjTarCycStaDataComReqDto_4.getCycleEndTime(),"D4-构造多条被评对象目标周期标准数据验证数据(公共)-D4-构造单条被评对象目标周期标准数据验证数据(达成度较上次增降幅)-周期结束时间不能为空",false);
Assert.isNull(buildSingleEvaObjTarCycStaDataComReqDto_4.getCycleTypeCode(),"D4-构造多条被评对象目标周期标准数据验证数据(公共)-D4-构造单条被评对象目标周期标准数据验证数据(达成度较上次增降幅)-周期类型标识不能为空",false);
Assert.isNull(buildSingleEvaObjTarCycStaDataComReqDto_4.getIsNewData(),"D4-构造多条被评对象目标周期标准数据验证数据(公共)-D4-构造单条被评对象目标周期标准数据验证数据(达成度较上次增降幅)-是否最新数据不能为空",false);
Assert.isNull(buildSingleEvaObjTarCycStaDataComReqDto_4.getTableTypeCode(),"D4-构造多条被评对象目标周期标准数据验证数据(公共)-D4-构造单条被评对象目标周期标准数据验证数据(达成度较上次增降幅)-归属内容表类型编码不能为空",false);
Assert.isNull(buildSingleEvaObjTarCycStaDataComReqDto_4.getEntityId(),"D4-构造多条被评对象目标周期标准数据验证数据(公共)-D4-构造单条被评对象目标周期标准数据验证数据(达成度较上次增降幅)-归属内容表主键ID不能为空",false);
Assert.isNull(buildSingleEvaObjTarCycStaDataComReqDto_4.getPersonLiableObjId(),"D4-构造多条被评对象目标周期标准数据验证数据(公共)-D4-构造单条被评对象目标周期标准数据验证数据(达成度较上次增降幅)-填报评价责任人对象ID不能为空",false);
Assert.isNull(buildSingleEvaObjTarCycStaDataComReqDto_4.getBizRoleObjId(),"D4-构造多条被评对象目标周期标准数据验证数据(公共)-D4-构造单条被评对象目标周期标准数据验证数据(达成度较上次增降幅)-填报评价责任人业务角色对象ID不能为空",false);
Assert.isNull(buildSingleEvaObjTarCycStaDataComReqDto_4.getBizRoleObjCode(),"D4-构造多条被评对象目标周期标准数据验证数据(公共)-D4-构造单条被评对象目标周期标准数据验证数据(达成度较上次增降幅)-填报评价责任人业务角色标识不能为空",false);
Assert.isNull(buildSingleEvaObjTarCycStaDataComReqDto_4.getPersonLiableTypeCode(),"D4-构造多条被评对象目标周期标准数据验证数据(公共)-D4-构造单条被评对象目标周期标准数据验证数据(达成度较上次增降幅)-填报评价责任人身份类型编码不能为空",false);
Assert.isNull(buildSingleEvaObjTarCycStaDataComReqDto_4.getBizRoleObjName(),"D4-构造多条被评对象目标周期标准数据验证数据(公共)-D4-构造单条被评对象目标周期标准数据验证数据(达成度较上次增降幅)-填报评价责任人业务角色对象名称不能为空",false);
      buildSingleEvaObjTarCycStaDataComRespDto_8 = buildSingleEvaObjTarCycStaDataCom(buildSingleEvaObjTarCycStaDataComReqDto_4);
      
      
      
    
//步骤6: D4-构造单条被评对象目标周期标准数据验证数据(公共) - buildSingleEvaObjTarCycStaDataCom
     BuildSingleEvaObjTarCycStaDataComRespDto buildSingleEvaObjTarCycStaDataComRespDto_10 = null;
    BuildSingleEvaObjTarCycStaDataComReqDto buildSingleEvaObjTarCycStaDataComReqDto_5=new BuildSingleEvaObjTarCycStaDataComReqDto();
  buildSingleEvaObjTarCycStaDataComReqDto_5.setDataType("REAL_TIME_SCORE");//sourceId:279546_1
buildSingleEvaObjTarCycStaDataComReqDto_5.setResultType("SYSTEM_AUTO_COUNT");//sourceId:279556_1
buildSingleEvaObjTarCycStaDataComReqDto_5.setIsNewData("TRUE");//sourceId:279557_1
buildSingleEvaObjTarCycStaDataComReqDto_5.setTableTypeCode("OMS_EVALUATION_OBJECT_TARGET_CYCLE");//sourceId:279547_1
buildSingleEvaObjTarCycStaDataComReqDto_5.setFromContentTableTypeCode("OMS_TSPE_CYCLE_STAGE_DATA");//sourceId:279549_1
if(reqDto!=null){
      buildSingleEvaObjTarCycStaDataComReqDto_5.setDataResult(reqDto.getRealTimeScore());//sourceId:279537_1
buildSingleEvaObjTarCycStaDataComReqDto_5.setUnit(reqDto.getRealTimeScoreUnit());//sourceId:279540_1
buildSingleEvaObjTarCycStaDataComReqDto_5.setPeriodId(reqDto.getCycleId());//sourceId:279541_1
buildSingleEvaObjTarCycStaDataComReqDto_5.setCycleStartTime(reqDto.getCycleStartTime());//sourceId:279542_1
buildSingleEvaObjTarCycStaDataComReqDto_5.setCycleEndTime(reqDto.getCycleEndTime());//sourceId:279543_1
buildSingleEvaObjTarCycStaDataComReqDto_5.setCycleTypeCode(reqDto.getCycleTypeCode());//sourceId:279544_1
buildSingleEvaObjTarCycStaDataComReqDto_5.setCycleTypeInstanceCode(reqDto.getCycleTypeInstanceCode());//sourceId:279545_1
buildSingleEvaObjTarCycStaDataComReqDto_5.setEntityId(reqDto.getEvaObjTargetCycleId());//sourceId:279548_1
buildSingleEvaObjTarCycStaDataComReqDto_5.setFromContentEntityId(reqDto.getCycleStageDataId());//sourceId:279550_1
buildSingleEvaObjTarCycStaDataComReqDto_5.setBelongToContentTypeCode(reqDto.getTargetCycleContentTypeCode());//sourceId:301704_1
buildSingleEvaObjTarCycStaDataComReqDto_5.setBelongToContentId(reqDto.getTargetCycleContentId());//sourceId:301705_1
buildSingleEvaObjTarCycStaDataComReqDto_5.setPersonLiableObjId(reqDto.getPersonLiableObjId());//sourceId:279551_1
buildSingleEvaObjTarCycStaDataComReqDto_5.setBizRoleObjId(reqDto.getBizRoleObjId());//sourceId:279552_1
buildSingleEvaObjTarCycStaDataComReqDto_5.setBizRoleObjCode(reqDto.getBizRoleObjCode());//sourceId:279553_1
buildSingleEvaObjTarCycStaDataComReqDto_5.setPersonLiableTypeCode(reqDto.getPersonLiableTypeCode());//sourceId:279554_1
buildSingleEvaObjTarCycStaDataComReqDto_5.setBizRoleObjName(reqDto.getBizRoleObjName());//sourceId:279555_1
    }
  
    /*D4-构造单条被评对象目标周期标准数据验证数据(实时得分)[4256]   */
    Assert.isNull(buildSingleEvaObjTarCycStaDataComReqDto_5.getDataType(),"D4-构造多条被评对象目标周期标准数据验证数据(公共)-D4-构造单条被评对象目标周期标准数据验证数据(实时得分)-数据类型编码不能为空",false);
Assert.isNull(buildSingleEvaObjTarCycStaDataComReqDto_5.getResultType(),"D4-构造多条被评对象目标周期标准数据验证数据(公共)-D4-构造单条被评对象目标周期标准数据验证数据(实时得分)-结果产生类型 不能为空",false);
Assert.isNull(buildSingleEvaObjTarCycStaDataComReqDto_5.getDataResult(),"D4-构造多条被评对象目标周期标准数据验证数据(公共)-D4-构造单条被评对象目标周期标准数据验证数据(实时得分)-数据值结果不能为空",false);
Assert.isNull(buildSingleEvaObjTarCycStaDataComReqDto_5.getPeriodId(),"D4-构造多条被评对象目标周期标准数据验证数据(公共)-D4-构造单条被评对象目标周期标准数据验证数据(实时得分)-周期ID不能为空",false);
Assert.isNull(buildSingleEvaObjTarCycStaDataComReqDto_5.getCycleStartTime(),"D4-构造多条被评对象目标周期标准数据验证数据(公共)-D4-构造单条被评对象目标周期标准数据验证数据(实时得分)-周期开始时间不能为空",false);
Assert.isNull(buildSingleEvaObjTarCycStaDataComReqDto_5.getCycleEndTime(),"D4-构造多条被评对象目标周期标准数据验证数据(公共)-D4-构造单条被评对象目标周期标准数据验证数据(实时得分)-周期结束时间不能为空",false);
Assert.isNull(buildSingleEvaObjTarCycStaDataComReqDto_5.getCycleTypeCode(),"D4-构造多条被评对象目标周期标准数据验证数据(公共)-D4-构造单条被评对象目标周期标准数据验证数据(实时得分)-周期类型标识不能为空",false);
Assert.isNull(buildSingleEvaObjTarCycStaDataComReqDto_5.getIsNewData(),"D4-构造多条被评对象目标周期标准数据验证数据(公共)-D4-构造单条被评对象目标周期标准数据验证数据(实时得分)-是否最新数据不能为空",false);
Assert.isNull(buildSingleEvaObjTarCycStaDataComReqDto_5.getTableTypeCode(),"D4-构造多条被评对象目标周期标准数据验证数据(公共)-D4-构造单条被评对象目标周期标准数据验证数据(实时得分)-归属内容表类型编码不能为空",false);
Assert.isNull(buildSingleEvaObjTarCycStaDataComReqDto_5.getEntityId(),"D4-构造多条被评对象目标周期标准数据验证数据(公共)-D4-构造单条被评对象目标周期标准数据验证数据(实时得分)-归属内容表主键ID不能为空",false);
Assert.isNull(buildSingleEvaObjTarCycStaDataComReqDto_5.getPersonLiableObjId(),"D4-构造多条被评对象目标周期标准数据验证数据(公共)-D4-构造单条被评对象目标周期标准数据验证数据(实时得分)-填报评价责任人对象ID不能为空",false);
Assert.isNull(buildSingleEvaObjTarCycStaDataComReqDto_5.getBizRoleObjId(),"D4-构造多条被评对象目标周期标准数据验证数据(公共)-D4-构造单条被评对象目标周期标准数据验证数据(实时得分)-填报评价责任人业务角色对象ID不能为空",false);
Assert.isNull(buildSingleEvaObjTarCycStaDataComReqDto_5.getBizRoleObjCode(),"D4-构造多条被评对象目标周期标准数据验证数据(公共)-D4-构造单条被评对象目标周期标准数据验证数据(实时得分)-填报评价责任人业务角色标识不能为空",false);
Assert.isNull(buildSingleEvaObjTarCycStaDataComReqDto_5.getPersonLiableTypeCode(),"D4-构造多条被评对象目标周期标准数据验证数据(公共)-D4-构造单条被评对象目标周期标准数据验证数据(实时得分)-填报评价责任人身份类型编码不能为空",false);
Assert.isNull(buildSingleEvaObjTarCycStaDataComReqDto_5.getBizRoleObjName(),"D4-构造多条被评对象目标周期标准数据验证数据(公共)-D4-构造单条被评对象目标周期标准数据验证数据(实时得分)-填报评价责任人业务角色对象名称不能为空",false);
      buildSingleEvaObjTarCycStaDataComRespDto_10 = buildSingleEvaObjTarCycStaDataCom(buildSingleEvaObjTarCycStaDataComReqDto_5);
      
      
      
    
BuildMultiEvaObjTarCycStaDataComRespDto retData = new BuildMultiEvaObjTarCycStaDataComRespDto();
  
  

  
  
return retData;
  }
/**
   * D4-删除单条被评对象目标周期标准数据(公共)[4379]
   * gen by moon at 11/25/2022, 4:55:06 PM
   */
  @Trace(operationName = "D4-删除单条被评对象目标周期标准数据(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public DeleteSingleEvaObjTarCycStaDataComRespDto deleteSingleEvaObjTarCycStaDataCom(DeleteSingleEvaObjTarCycStaDataComReqDto reqDto){
    
      
      //步骤0: M4-查询单条被评对象目标周期标准数据列表 - querySingleEvaObjTarCycStaDataList
     List<OmsStandardDataResult> listOmsStandardDataResult =new ArrayList<>();
    QuerySingleEvaObjTarCycStaDataListReq querySingleEvaObjTarCycStaDataListReq=new QuerySingleEvaObjTarCycStaDataListReq();
  if(reqDto!=null){
      querySingleEvaObjTarCycStaDataListReq.setBelongToContentTypeCode(reqDto.getBelongToContentTypeCode());//SimpleFieldAssign//sourceId:305659_1
querySingleEvaObjTarCycStaDataListReq.setBelongToContentId(reqDto.getBelongToContentId());//SimpleFieldAssign//sourceId:305660_1
    }
  
    /*M4-查询单条被评对象目标周期标准数据列表[4380]   */
    Assert.isNull(querySingleEvaObjTarCycStaDataListReq.getBelongToContentTypeCode(),"D4-删除单条被评对象目标周期标准数据(公共)-M4-查询单条被评对象目标周期标准数据列表-数据归属内容类型编码不能为空",false);
Assert.isNull(querySingleEvaObjTarCycStaDataListReq.getBelongToContentId(),"D4-删除单条被评对象目标周期标准数据(公共)-M4-查询单条被评对象目标周期标准数据列表-数据归属内容ID不能为空",false);
      listOmsStandardDataResult = mOmsStandardDataResultService.querySingleEvaObjTarCycStaDataList(querySingleEvaObjTarCycStaDataListReq);
      
      
      
    
//步骤1: M4-批量删多条被评对象目标周期标准数据 - batchDeleteMultiEvaObjTarCycStaData
     boolean bOOLEAN ;
    if(listOmsStandardDataResult !=null&& !CollectionUtil.isEmpty(listOmsStandardDataResult)&& listOmsStandardDataResult.size()>0 ){
          List<String> listString=new ArrayList<>();
  listString = listOmsStandardDataResult.stream().map(item->item.getDataResultId())
        .collect(Collectors.toList());/*list-to-strings*///sourceId:305671_1
  
    /*M4-批量删多条被评对象目标周期标准数据[4374]   */
    
      bOOLEAN = mOmsStandardDataResultService.batchDeleteMultiEvaObjTarCycStaData(listString);
      
      
      
           }
    
DeleteSingleEvaObjTarCycStaDataComRespDto retData = new DeleteSingleEvaObjTarCycStaDataComRespDto();
  
  

  
  
return retData;
  }
/**
   * D4-批量删多条被评对象目标周期标准数据(公共)[4372]
   * gen by moon at 11/25/2022, 4:55:16 PM
   */
  @Trace(operationName = "D4-批量删多条被评对象目标周期标准数据(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public BatchDeleteMultiEvaObjTarCycStaDataComRespDto batchDeleteMultiEvaObjTarCycStaDataCom(BatchDeleteMultiEvaObjTarCycStaDataComReqDto reqDto){
    
      
      //步骤0: M4-查询多条被评对象目标周期标准数据列表 - queryMultiEvaObjTarCycStaDataList
     List<OmsStandardDataResult> listOmsStandardDataResult =new ArrayList<>();
    QueryMultiEvaObjTarCycStaDataListReq queryMultiEvaObjTarCycStaDataListReq=new QueryMultiEvaObjTarCycStaDataListReq();
  if(reqDto!=null){
      queryMultiEvaObjTarCycStaDataListReq.setMultiEvaObjTarCycStaDataList(reqDto.getMultiEvaObjTarCycStaDataList());//list-field-assign//sourceId:304372_1
queryMultiEvaObjTarCycStaDataListReq.setBelongToContentTypeCode(reqDto.getBelongToContentTypeCode());//SimpleFieldAssign//sourceId:304373_1
    }
  
    /*M4-查询多条被评对象目标周期标准数据列表[4373]   */
    
      listOmsStandardDataResult = mOmsStandardDataResultService.queryMultiEvaObjTarCycStaDataList(queryMultiEvaObjTarCycStaDataListReq);
      
      
      
    
//步骤1: M4-批量删多条被评对象目标周期标准数据 - batchDeleteMultiEvaObjTarCycStaData
     boolean bOOLEAN ;
    if(listOmsStandardDataResult !=null&& !CollectionUtil.isEmpty(listOmsStandardDataResult)&& listOmsStandardDataResult.size()>0 ){
          List<String> listString=new ArrayList<>();
  listString = listOmsStandardDataResult.stream().map(item->item.getDataResultId())
        .collect(Collectors.toList());/*list-to-strings*///sourceId:304376_1
  
    /*M4-批量删多条被评对象目标周期标准数据[4374]   */
    
      bOOLEAN = mOmsStandardDataResultService.batchDeleteMultiEvaObjTarCycStaData(listString);
      
      
      
           }
    
BatchDeleteMultiEvaObjTarCycStaDataComRespDto retData = new BatchDeleteMultiEvaObjTarCycStaDataComRespDto();
  
  

  
  
return retData;
  }
/**
   * D4-1-01一键删除多条被评对象目标周期标准数据验证数据(公共)[4447]
   * gen by moon at 6/22/2024, 9:48:23 AM
   */
  @Trace(operationName = "D4-1-01一键删除多条被评对象目标周期标准数据验证数据(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public AutoDeleteMultiEvaObjTarCycStaDataComRespDto autoDeleteMultiEvaObjTarCycStaDataCom(AutoDeleteMultiEvaObjTarCycStaDataComReqDto reqDto){
    
      
      //步骤0: M4-1-01查询被评对象目标周期标准数据列表 - queryEvaObjTarCycStaDataList
     List<OmsStandardDataResult> listOmsStandardDataResult =new ArrayList<>();
    QueryEvaObjTarCycStaDataListReq queryEvaObjTarCycStaDataListReq=new QueryEvaObjTarCycStaDataListReq();
  if(reqDto!=null){
queryEvaObjTarCycStaDataListReq.setEntityId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:311607_1
queryEvaObjTarCycStaDataListReq.setFromContentEntityId(reqDto.getFromContentEntityId());//SimpleFieldAssign//sourceId:1886373_1
queryEvaObjTarCycStaDataListReq.setThemeContentId(reqDto.getThemeContentId());//SimpleFieldAssign//sourceId:1032511_1
    }
  
    /*M4-1-01查询被评对象目标周期标准数据列表[4460]   */

      listOmsStandardDataResult = mOmsStandardDataResultService.queryEvaObjTarCycStaDataList(queryEvaObjTarCycStaDataListReq)/*vcase invoke 本地 method 方法调用;*/;
      
      
      
    
//步骤1: M4-1-01一键删除被评对象目标周期标准数据验证数据 - autoDeleteEvaObjTarCycStaData
     boolean bOOLEAN ;
    if(listOmsStandardDataResult !=null&& !CollectionUtil.isEmpty(listOmsStandardDataResult)&& listOmsStandardDataResult.size()>0 ){
          List<String> listString=new ArrayList<>();
  if(listOmsStandardDataResult!= null&& !CollectionUtil.isEmpty(listOmsStandardDataResult)&&  listOmsStandardDataResult !=null&& !CollectionUtil.isEmpty(listOmsStandardDataResult)){
  listString = listOmsStandardDataResult.stream().map(item->item.getDataResultId())
        .collect(Collectors.toList());/*list-to-strings*///sourceId:311610_1
    }
  
    /*M4-1-01一键删除被评对象目标周期标准数据验证数据[4425]   */
    
      bOOLEAN = mOmsStandardDataResultService.autoDeleteEvaObjTarCycStaData(listString)/*vcase invoke 本地 method 方法调用;*/;
      
      
      
           }
    
AutoDeleteMultiEvaObjTarCycStaDataComRespDto retData = new AutoDeleteMultiEvaObjTarCycStaDataComRespDto();
  
  

  
  
return retData;
  }
/**
   * D4-1-01修改单条被评对象目标周期标准数据[4535]
   * gen by moon at 9/10/2022, 5:28:55 PM
   */
  @Trace(operationName = "D4-1-01修改单条被评对象目标周期标准数据")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public UpdateSingleEvaObjTarCycStaDataRespDto updateSingleEvaObjTarCycStaData(UpdateSingleEvaObjTarCycStaDataReqDto reqDto){
    
      
      //步骤0: M4-1-01查询单条被评对象目标周期标准数据详情 - querySingleEvaObjTarCycStaDataDetail
     OmsStandardDataResult omsStandardDataResult = null;
    QuerySingleEvaObjTarCycStaDataDetailReq querySingleEvaObjTarCycStaDataDetailReq=new QuerySingleEvaObjTarCycStaDataDetailReq();
  querySingleEvaObjTarCycStaDataDetailReq.setTableTypeCode("OMS_EVALUATION_OBJECT_TARGET_CYCLE");//sourceId:320816_1
querySingleEvaObjTarCycStaDataDetailReq.setDataType("ACTUAL_VALUE");//sourceId:320820_1
if(reqDto!=null){
      querySingleEvaObjTarCycStaDataDetailReq.setPeriodId(reqDto.getPeriodId());//sourceId:320815_1
querySingleEvaObjTarCycStaDataDetailReq.setEntityId(reqDto.getEntityId());//sourceId:320817_1
    }
  
    /*M4-1-01查实际值[4536]   */
    Assert.isNull(querySingleEvaObjTarCycStaDataDetailReq.getPeriodId(),"D4-1-01修改单条被评对象目标周期标准数据-M4-1-01查实际值-周期ID不能为空",false);
Assert.isNull(querySingleEvaObjTarCycStaDataDetailReq.getTableTypeCode(),"D4-1-01修改单条被评对象目标周期标准数据-M4-1-01查实际值-归属内容表类型编码不能为空",false);
Assert.isNull(querySingleEvaObjTarCycStaDataDetailReq.getEntityId(),"D4-1-01修改单条被评对象目标周期标准数据-M4-1-01查实际值-归属内容表主键ID不能为空",false);
Assert.isNull(querySingleEvaObjTarCycStaDataDetailReq.getDataType(),"D4-1-01修改单条被评对象目标周期标准数据-M4-1-01查实际值-数据类型编码不能为空",false);
      omsStandardDataResult = mOmsStandardDataResultService.querySingleEvaObjTarCycStaDataDetail(querySingleEvaObjTarCycStaDataDetailReq);
      
      
      
    
//步骤1: M4-1-01修改单条被评对象目标周期标准数据 - updateSingleEvaObjTarCycStaData
     boolean bOOLEAN ;
    if(omsStandardDataResult !=null){
          OmsStandardDataResult omsStandardDataResult_2=new OmsStandardDataResult();
  if(omsStandardDataResult!=null){
      omsStandardDataResult_2.setDataResultId(omsStandardDataResult.getDataResultId());//sourceId:320835_1
    }
if(reqDto!=null){
      omsStandardDataResult_2.setDataResult(reqDto.getActualValue());//sourceId:320836_1
omsStandardDataResult_2.setParentDataResult(reqDto.getParentActualValue());//sourceId:320837_1
omsStandardDataResult_2.setUnit(reqDto.getUnit());//sourceId:320838_1
omsStandardDataResult_2.setIsNewData(reqDto.getIsNewData());//sourceId:320839_1
omsStandardDataResult_2.setSubjectLifeCycle(reqDto.getSubjectLifeCycle());//sourceId:320840_1
omsStandardDataResult_2.setIsArchive(reqDto.getIsArchive());//sourceId:320841_1
    }
  
    /*M4-1-01修改实际值[4537]   */
    Assert.isNull(omsStandardDataResult_2.getDataResultId(),"D4-1-01修改单条被评对象目标周期标准数据-M4-1-01修改实际值-数据结果ID 不能为空",false);
      bOOLEAN = mOmsStandardDataResultService.updateSingleEvaObjTarCycStaData(omsStandardDataResult_2);
      
      
      
           }
    
//步骤2: M4-1-01查询单条被评对象目标周期标准数据详情 - querySingleEvaObjTarCycStaDataDetail
     OmsStandardDataResult omsStandardDataResult_3 = null;
    QuerySingleEvaObjTarCycStaDataDetailReq querySingleEvaObjTarCycStaDataDetailReq_1=new QuerySingleEvaObjTarCycStaDataDetailReq();
  querySingleEvaObjTarCycStaDataDetailReq_1.setTableTypeCode("OMS_EVALUATION_OBJECT_TARGET_CYCLE");//sourceId:320852_1
querySingleEvaObjTarCycStaDataDetailReq_1.setDataType("PROGRESS_VALUE");//sourceId:320855_1
if(reqDto!=null){
      querySingleEvaObjTarCycStaDataDetailReq_1.setPeriodId(reqDto.getPeriodId());//sourceId:320851_1
querySingleEvaObjTarCycStaDataDetailReq_1.setEntityId(reqDto.getEntityId());//sourceId:320853_1
    }
  
    /*M4-1-01查进度值[4536]   */
    Assert.isNull(querySingleEvaObjTarCycStaDataDetailReq_1.getPeriodId(),"D4-1-01修改单条被评对象目标周期标准数据-M4-1-01查进度值-周期ID不能为空",false);
Assert.isNull(querySingleEvaObjTarCycStaDataDetailReq_1.getTableTypeCode(),"D4-1-01修改单条被评对象目标周期标准数据-M4-1-01查进度值-归属内容表类型编码不能为空",false);
Assert.isNull(querySingleEvaObjTarCycStaDataDetailReq_1.getEntityId(),"D4-1-01修改单条被评对象目标周期标准数据-M4-1-01查进度值-归属内容表主键ID不能为空",false);
Assert.isNull(querySingleEvaObjTarCycStaDataDetailReq_1.getDataType(),"D4-1-01修改单条被评对象目标周期标准数据-M4-1-01查进度值-数据类型编码不能为空",false);
      omsStandardDataResult_3 = mOmsStandardDataResultService.querySingleEvaObjTarCycStaDataDetail(querySingleEvaObjTarCycStaDataDetailReq_1);
      
      
      
    
//步骤3: M4-1-01修改单条被评对象目标周期标准数据 - updateSingleEvaObjTarCycStaData
     boolean bOOLEAN_1 ;
    if(omsStandardDataResult_3 !=null){
          OmsStandardDataResult omsStandardDataResult_5=new OmsStandardDataResult();
  if(omsStandardDataResult_3!=null){
      omsStandardDataResult_5.setDataResultId(omsStandardDataResult_3.getDataResultId());//sourceId:320876_1
    }
if(reqDto!=null){
      omsStandardDataResult_5.setDataResult(reqDto.getProgressValue());//sourceId:320877_1
omsStandardDataResult_5.setParentDataResult(reqDto.getParentProgressValue());//sourceId:320878_1
omsStandardDataResult_5.setUnit(reqDto.getUnit());//sourceId:320879_1
omsStandardDataResult_5.setIsNewData(reqDto.getIsNewData());//sourceId:320880_1
omsStandardDataResult_5.setSubjectLifeCycle(reqDto.getSubjectLifeCycle());//sourceId:320881_1
omsStandardDataResult_5.setIsArchive(reqDto.getIsArchive());//sourceId:320882_1
    }
  
    /*M4-1-01修改进度值[4537]   */
    Assert.isNull(omsStandardDataResult_5.getDataResultId(),"D4-1-01修改单条被评对象目标周期标准数据-M4-1-01修改进度值-数据结果ID 不能为空",false);
      bOOLEAN_1 = mOmsStandardDataResultService.updateSingleEvaObjTarCycStaData(omsStandardDataResult_5);
      
      
      
           }
    
//步骤4: M4-1-01查询单条被评对象目标周期标准数据详情 - querySingleEvaObjTarCycStaDataDetail
     OmsStandardDataResult omsStandardDataResult_6 = null;
    QuerySingleEvaObjTarCycStaDataDetailReq querySingleEvaObjTarCycStaDataDetailReq_2=new QuerySingleEvaObjTarCycStaDataDetailReq();
  querySingleEvaObjTarCycStaDataDetailReq_2.setTableTypeCode("OMS_EVALUATION_OBJECT_TARGET_CYCLE");//sourceId:320857_1
querySingleEvaObjTarCycStaDataDetailReq_2.setDataType("REACH");//sourceId:320860_1
if(reqDto!=null){
      querySingleEvaObjTarCycStaDataDetailReq_2.setPeriodId(reqDto.getPeriodId());//sourceId:320856_1
querySingleEvaObjTarCycStaDataDetailReq_2.setEntityId(reqDto.getEntityId());//sourceId:320858_1
    }
  
    /*M4-1-01查达成度[4536]   */
    Assert.isNull(querySingleEvaObjTarCycStaDataDetailReq_2.getPeriodId(),"D4-1-01修改单条被评对象目标周期标准数据-M4-1-01查达成度-周期ID不能为空",false);
Assert.isNull(querySingleEvaObjTarCycStaDataDetailReq_2.getTableTypeCode(),"D4-1-01修改单条被评对象目标周期标准数据-M4-1-01查达成度-归属内容表类型编码不能为空",false);
Assert.isNull(querySingleEvaObjTarCycStaDataDetailReq_2.getEntityId(),"D4-1-01修改单条被评对象目标周期标准数据-M4-1-01查达成度-归属内容表主键ID不能为空",false);
Assert.isNull(querySingleEvaObjTarCycStaDataDetailReq_2.getDataType(),"D4-1-01修改单条被评对象目标周期标准数据-M4-1-01查达成度-数据类型编码不能为空",false);
      omsStandardDataResult_6 = mOmsStandardDataResultService.querySingleEvaObjTarCycStaDataDetail(querySingleEvaObjTarCycStaDataDetailReq_2);
      
      
      
    
//步骤5: M4-1-01修改单条被评对象目标周期标准数据 - updateSingleEvaObjTarCycStaData
     boolean bOOLEAN_2 ;
    if(omsStandardDataResult_6 !=null){
          OmsStandardDataResult omsStandardDataResult_8=new OmsStandardDataResult();
  if(omsStandardDataResult_6!=null){
      omsStandardDataResult_8.setDataResultId(omsStandardDataResult_6.getDataResultId());//sourceId:320940_1
    }
if(reqDto!=null){
      omsStandardDataResult_8.setDataResult(reqDto.getReach());//sourceId:320941_1
omsStandardDataResult_8.setParentDataResult(reqDto.getParentReach());//sourceId:320942_1
omsStandardDataResult_8.setUnit(reqDto.getUnit());//sourceId:320943_1
omsStandardDataResult_8.setIsNewData(reqDto.getIsNewData());//sourceId:320944_1
omsStandardDataResult_8.setSubjectLifeCycle(reqDto.getSubjectLifeCycle());//sourceId:320945_1
omsStandardDataResult_8.setIsArchive(reqDto.getIsArchive());//sourceId:320946_1
    }
  
    /*M4-1-01修改达成度[4537]   */
    Assert.isNull(omsStandardDataResult_8.getDataResultId(),"D4-1-01修改单条被评对象目标周期标准数据-M4-1-01修改达成度-数据结果ID 不能为空",false);
      bOOLEAN_2 = mOmsStandardDataResultService.updateSingleEvaObjTarCycStaData(omsStandardDataResult_8);
      
      
      
           }
    
//步骤6: M4-1-01查询单条被评对象目标周期标准数据详情 - querySingleEvaObjTarCycStaDataDetail
     OmsStandardDataResult omsStandardDataResult_9 = null;
    QuerySingleEvaObjTarCycStaDataDetailReq querySingleEvaObjTarCycStaDataDetailReq_3=new QuerySingleEvaObjTarCycStaDataDetailReq();
  querySingleEvaObjTarCycStaDataDetailReq_3.setTableTypeCode("OMS_EVALUATION_OBJECT_TARGET_CYCLE");//sourceId:320862_1
querySingleEvaObjTarCycStaDataDetailReq_3.setDataType("REAL_TIME_SCORE");//sourceId:320865_1
if(reqDto!=null){
      querySingleEvaObjTarCycStaDataDetailReq_3.setPeriodId(reqDto.getPeriodId());//sourceId:320861_1
querySingleEvaObjTarCycStaDataDetailReq_3.setEntityId(reqDto.getEntityId());//sourceId:320863_1
    }
  
    /*M4-1-01查实时得分[4536]   */
    Assert.isNull(querySingleEvaObjTarCycStaDataDetailReq_3.getPeriodId(),"D4-1-01修改单条被评对象目标周期标准数据-M4-1-01查实时得分-周期ID不能为空",false);
Assert.isNull(querySingleEvaObjTarCycStaDataDetailReq_3.getTableTypeCode(),"D4-1-01修改单条被评对象目标周期标准数据-M4-1-01查实时得分-归属内容表类型编码不能为空",false);
Assert.isNull(querySingleEvaObjTarCycStaDataDetailReq_3.getEntityId(),"D4-1-01修改单条被评对象目标周期标准数据-M4-1-01查实时得分-归属内容表主键ID不能为空",false);
Assert.isNull(querySingleEvaObjTarCycStaDataDetailReq_3.getDataType(),"D4-1-01修改单条被评对象目标周期标准数据-M4-1-01查实时得分-数据类型编码不能为空",false);
      omsStandardDataResult_9 = mOmsStandardDataResultService.querySingleEvaObjTarCycStaDataDetail(querySingleEvaObjTarCycStaDataDetailReq_3);
      
      
      
    
//步骤7: M4-1-01修改单条被评对象目标周期标准数据 - updateSingleEvaObjTarCycStaData
     boolean bOOLEAN_3 ;
    if(omsStandardDataResult_9 !=null){
          OmsStandardDataResult omsStandardDataResult_11=new OmsStandardDataResult();
  if(omsStandardDataResult_9!=null){
      omsStandardDataResult_11.setDataResultId(omsStandardDataResult_9.getDataResultId());//sourceId:320949_1
    }
if(reqDto!=null){
      omsStandardDataResult_11.setDataResult(reqDto.getRealTimeScore());//sourceId:320950_1
omsStandardDataResult_11.setParentDataResult(reqDto.getParentRealTimeScore());//sourceId:320951_1
omsStandardDataResult_11.setUnit(reqDto.getUnit());//sourceId:320952_1
omsStandardDataResult_11.setIsNewData(reqDto.getIsNewData());//sourceId:320953_1
omsStandardDataResult_11.setSubjectLifeCycle(reqDto.getSubjectLifeCycle());//sourceId:320954_1
omsStandardDataResult_11.setIsArchive(reqDto.getIsArchive());//sourceId:320955_1
    }
  
    /*M4-1-01修改实时得分[4537]   */
    Assert.isNull(omsStandardDataResult_11.getDataResultId(),"D4-1-01修改单条被评对象目标周期标准数据-M4-1-01修改实时得分-数据结果ID 不能为空",false);
      bOOLEAN_3 = mOmsStandardDataResultService.updateSingleEvaObjTarCycStaData(omsStandardDataResult_11);
      
      
      
           }
    
//步骤8: M4-1-01查询单条被评对象目标周期标准数据详情 - querySingleEvaObjTarCycStaDataDetail
     OmsStandardDataResult omsStandardDataResult_12 = null;
    QuerySingleEvaObjTarCycStaDataDetailReq querySingleEvaObjTarCycStaDataDetailReq_4=new QuerySingleEvaObjTarCycStaDataDetailReq();
  querySingleEvaObjTarCycStaDataDetailReq_4.setTableTypeCode("OMS_EVALUATION_OBJECT_TARGET_CYCLE");//sourceId:320867_1
querySingleEvaObjTarCycStaDataDetailReq_4.setDataType("PROGRESS_FROM_LAST_RATIO");//sourceId:320870_1
if(reqDto!=null){
      querySingleEvaObjTarCycStaDataDetailReq_4.setPeriodId(reqDto.getPeriodId());//sourceId:320866_1
querySingleEvaObjTarCycStaDataDetailReq_4.setEntityId(reqDto.getEntityId());//sourceId:320868_1
    }
  
    /*M4-1-01查进度较上次增降幅[4536]   */
    Assert.isNull(querySingleEvaObjTarCycStaDataDetailReq_4.getPeriodId(),"D4-1-01修改单条被评对象目标周期标准数据-M4-1-01查进度较上次增降幅-周期ID不能为空",false);
Assert.isNull(querySingleEvaObjTarCycStaDataDetailReq_4.getTableTypeCode(),"D4-1-01修改单条被评对象目标周期标准数据-M4-1-01查进度较上次增降幅-归属内容表类型编码不能为空",false);
Assert.isNull(querySingleEvaObjTarCycStaDataDetailReq_4.getEntityId(),"D4-1-01修改单条被评对象目标周期标准数据-M4-1-01查进度较上次增降幅-归属内容表主键ID不能为空",false);
Assert.isNull(querySingleEvaObjTarCycStaDataDetailReq_4.getDataType(),"D4-1-01修改单条被评对象目标周期标准数据-M4-1-01查进度较上次增降幅-数据类型编码不能为空",false);
      omsStandardDataResult_12 = mOmsStandardDataResultService.querySingleEvaObjTarCycStaDataDetail(querySingleEvaObjTarCycStaDataDetailReq_4);
      
      
      
    
//步骤9: M4-1-01修改单条被评对象目标周期标准数据 - updateSingleEvaObjTarCycStaData
     boolean bOOLEAN_4 ;
    if(omsStandardDataResult_12 !=null){
          OmsStandardDataResult omsStandardDataResult_14=new OmsStandardDataResult();
  if(omsStandardDataResult_12!=null){
      omsStandardDataResult_14.setDataResultId(omsStandardDataResult_12.getDataResultId());//sourceId:320968_1
    }
if(reqDto!=null){
      omsStandardDataResult_14.setDataResult(reqDto.getProgressFromLastRatio());//sourceId:320969_1
omsStandardDataResult_14.setParentDataResult(reqDto.getParentProgressFromLastRatio());//sourceId:320970_1
omsStandardDataResult_14.setUnit(reqDto.getUnit());//sourceId:320971_1
omsStandardDataResult_14.setIsNewData(reqDto.getIsNewData());//sourceId:320972_1
omsStandardDataResult_14.setSubjectLifeCycle(reqDto.getSubjectLifeCycle());//sourceId:320973_1
omsStandardDataResult_14.setIsArchive(reqDto.getIsArchive());//sourceId:320974_1
    }
  
    /*M4-1-01修改进度较上次增降幅[4537]   */
    Assert.isNull(omsStandardDataResult_14.getDataResultId(),"D4-1-01修改单条被评对象目标周期标准数据-M4-1-01修改进度较上次增降幅-数据结果ID 不能为空",false);
      bOOLEAN_4 = mOmsStandardDataResultService.updateSingleEvaObjTarCycStaData(omsStandardDataResult_14);
      
      
      
           }
    
//步骤10: M4-1-01查询单条被评对象目标周期标准数据详情 - querySingleEvaObjTarCycStaDataDetail
     OmsStandardDataResult omsStandardDataResult_15 = null;
    QuerySingleEvaObjTarCycStaDataDetailReq querySingleEvaObjTarCycStaDataDetailReq_5=new QuerySingleEvaObjTarCycStaDataDetailReq();
  querySingleEvaObjTarCycStaDataDetailReq_5.setTableTypeCode("OMS_EVALUATION_OBJECT_TARGET_CYCLE");//sourceId:320872_1
querySingleEvaObjTarCycStaDataDetailReq_5.setDataType("ACTUAL_FROM_LAST_TIME_RATIO");//sourceId:320875_1
if(reqDto!=null){
      querySingleEvaObjTarCycStaDataDetailReq_5.setPeriodId(reqDto.getPeriodId());//sourceId:320871_1
querySingleEvaObjTarCycStaDataDetailReq_5.setEntityId(reqDto.getEntityId());//sourceId:320873_1
    }
  
    /*M4-1-01查达成度较上次增降幅[4536]   */
    Assert.isNull(querySingleEvaObjTarCycStaDataDetailReq_5.getPeriodId(),"D4-1-01修改单条被评对象目标周期标准数据-M4-1-01查达成度较上次增降幅-周期ID不能为空",false);
Assert.isNull(querySingleEvaObjTarCycStaDataDetailReq_5.getTableTypeCode(),"D4-1-01修改单条被评对象目标周期标准数据-M4-1-01查达成度较上次增降幅-归属内容表类型编码不能为空",false);
Assert.isNull(querySingleEvaObjTarCycStaDataDetailReq_5.getEntityId(),"D4-1-01修改单条被评对象目标周期标准数据-M4-1-01查达成度较上次增降幅-归属内容表主键ID不能为空",false);
Assert.isNull(querySingleEvaObjTarCycStaDataDetailReq_5.getDataType(),"D4-1-01修改单条被评对象目标周期标准数据-M4-1-01查达成度较上次增降幅-数据类型编码不能为空",false);
      omsStandardDataResult_15 = mOmsStandardDataResultService.querySingleEvaObjTarCycStaDataDetail(querySingleEvaObjTarCycStaDataDetailReq_5);
      
      
      
    
//步骤11: M4-1-01修改单条被评对象目标周期标准数据 - updateSingleEvaObjTarCycStaData
     boolean bOOLEAN_5 ;
    if(omsStandardDataResult_15 !=null){
          OmsStandardDataResult omsStandardDataResult_17=new OmsStandardDataResult();
  if(omsStandardDataResult_15!=null){
      omsStandardDataResult_17.setDataResultId(omsStandardDataResult_15.getDataResultId());//sourceId:320960_1
    }
if(reqDto!=null){
      omsStandardDataResult_17.setDataResult(reqDto.getActualFromLastTimeRatio());//sourceId:320961_1
omsStandardDataResult_17.setParentDataResult(reqDto.getParentActualFromLastTimeRatio());//sourceId:320962_1
omsStandardDataResult_17.setUnit(reqDto.getUnit());//sourceId:320963_1
omsStandardDataResult_17.setIsNewData(reqDto.getIsNewData());//sourceId:320964_1
omsStandardDataResult_17.setSubjectLifeCycle(reqDto.getSubjectLifeCycle());//sourceId:320965_1
omsStandardDataResult_17.setIsArchive(reqDto.getIsArchive());//sourceId:320966_1
    }
  
    /*M4-1-01修改达成度较上次增降幅[4537]   */
    Assert.isNull(omsStandardDataResult_17.getDataResultId(),"D4-1-01修改单条被评对象目标周期标准数据-M4-1-01修改达成度较上次增降幅-数据结果ID 不能为空",false);
      bOOLEAN_5 = mOmsStandardDataResultService.updateSingleEvaObjTarCycStaData(omsStandardDataResult_17);
      
      
      
           }
    
UpdateSingleEvaObjTarCycStaDataRespDto retData = new UpdateSingleEvaObjTarCycStaDataRespDto();
  
  

  
  
return retData;
  }
/**
   * D4执行刷模板标准数据（运维）[9676]
   * gen by moon at 5/30/2024, 4:13:57 PM
   */
  @Trace(operationName = "D4执行刷模板标准数据（运维）")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementBrushTempStandardDataRespDto implementBrushTempStandardData(ImplementBrushTempStandardDataReqDto reqDto){


      //virtualUsage M4查询评价模板下标准数据列表（用于循环发牌使用）  69331
      List<OmsStandardDataResult> listOmsStandardDataResult =new ArrayList<>();
    QuerySingleEvaObjTarCycStaDataListReq querySingleEvaObjTarCycStaDataListReq=new QuerySingleEvaObjTarCycStaDataListReq();
  if(reqDto!=null){
      querySingleEvaObjTarCycStaDataListReq.setResultType(reqDto.getResultType());//SimpleFieldAssign//sourceId:1825343_1_69331
querySingleEvaObjTarCycStaDataListReq.setDataUsageSceneCode(reqDto.getDataUsageSceneCode());//SimpleFieldAssign//sourceId:1825344_1_69331
querySingleEvaObjTarCycStaDataListReq.setThemeContentId(reqDto.getThemeContentId());//SimpleFieldAssign//sourceId:1825347_1_69331
    }

    /*M4查询评价模板下标准数据列表（用于循环发牌使用）[4380]   */
    Assert.isNull(querySingleEvaObjTarCycStaDataListReq.getDataUsageSceneCode(),"D4执行刷模板标准数据（运维）-M4查询评价模板下标准数据列表（用于循环发牌使用）-数据业务场景不能为空",false);
Assert.isNull(querySingleEvaObjTarCycStaDataListReq.getThemeContentId(),"D4执行刷模板标准数据（运维）-M4查询评价模板下标准数据列表（用于循环发牌使用）-主题内容ID不能为空",false);
      listOmsStandardDataResult = mOmsStandardDataResultService.querySingleEvaObjTarCycStaDataList(querySingleEvaObjTarCycStaDataListReq)/*vcase invoke 本地 method 方法调用;*/;



if((listOmsStandardDataResult!= null&&  listOmsStandardDataResult !=null && listOmsStandardDataResult.size()>0)) {
        //if(M4查询评价模板下标准数据列表（用于循环发牌使用）.多条被评对象目标周期标准数据列表数据集条数 大于 0)  69332

//ModelCode: circulationCollections
        for (OmsStandardDataResult circulationCollectionsRes: listOmsStandardDataResult){

ObtainTargetBelongCycleComRespDto obtainTargetBelongCycleComRespDto = null;
    ObtainTargetBelongCycleComReqDto obtainTargetBelongCycleComReqDto=new ObtainTargetBelongCycleComReqDto();
  obtainTargetBelongCycleComReqDto.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:1825362_1_69335
if(reqDto!=null){
      obtainTargetBelongCycleComReqDto.setEvaObjEntityId(reqDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1825456_1_69335
obtainTargetBelongCycleComReqDto.setEvaObjTypeCode(reqDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1825455_1_69335
obtainTargetBelongCycleComReqDto.setEvaluationTemplateId(reqDto.getThemeContentId());//SimpleFieldAssign//sourceId:1825453_1_69335
    }
if(circulationCollectionsRes!=null){
      obtainTargetBelongCycleComReqDto.setCycleId(circulationCollectionsRes.getPeriodId());//SimpleFieldAssign//sourceId:1825452_1_69335
obtainTargetBelongCycleComReqDto.setParentSubMidCycleType(circulationCollectionsRes.getParentSubMidCycleType());//SimpleFieldAssign//sourceId:1825506_1_69335
obtainTargetBelongCycleComReqDto.setEntityId(circulationCollectionsRes.getEntityId());//SimpleFieldAssign//sourceId:1825483_1_69335
    }

    /*D3标准数据对应的目标归属周期（用于修正当前标准数据使用）[8739]   */
    Assert.isNull(obtainTargetBelongCycleComReqDto.getEvaObjEntityId(),"D4执行刷模板标准数据（运维）-D3标准数据对应的目标归属周期（用于修正当前标准数据使用）-主树被评对象内容表主键ID不能为空",false);
Assert.isNull(obtainTargetBelongCycleComReqDto.getEvaObjTypeCode(),"D4执行刷模板标准数据（运维）-D3标准数据对应的目标归属周期（用于修正当前标准数据使用）-主树被评对象类型编码不能为空",false);
Assert.isNull(obtainTargetBelongCycleComReqDto.getCycleId(),"D4执行刷模板标准数据（运维）-D3标准数据对应的目标归属周期（用于修正当前标准数据使用）-归属周期ID不能为空",false);
Assert.isNull(obtainTargetBelongCycleComReqDto.getEntityId(),"D4执行刷模板标准数据（运维）-D3标准数据对应的目标归属周期（用于修正当前标准数据使用）-归属内容表主键ID不能为空",false);
Assert.isNull(obtainTargetBelongCycleComReqDto.getEvaluationTemplateId(),"D4执行刷模板标准数据（运维）-D3标准数据对应的目标归属周期（用于修正当前标准数据使用）-冗余评价模板ID不能为空",false);
Assert.isNull(obtainTargetBelongCycleComReqDto.getSpaceId(),"D4执行刷模板标准数据（运维）-D3标准数据对应的目标归属周期（用于修正当前标准数据使用）-创建于空间ID不能为空",false);
      obtainTargetBelongCycleComRespDto = fwAppTargetCalcClient.obtainTargetBelongCycleCom(obtainTargetBelongCycleComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



PreparationPreviousStandardDataResultComRespDto preparationPreviousStandardDataResultComRespDto = null;
    if(obtainTargetBelongCycleComRespDto !=null){
          PreparationPreviousStandardDataResultComReqDto preparationPreviousStandardDataResultComReqDto=new PreparationPreviousStandardDataResultComReqDto();
  if(circulationCollectionsRes!=null){
      preparationPreviousStandardDataResultComReqDto.setDataType(circulationCollectionsRes.getDataType());//SimpleFieldAssign//sourceId:1825508_1_69338
preparationPreviousStandardDataResultComReqDto.setAccountId(circulationCollectionsRes.getAccountId());//SimpleFieldAssign//sourceId:1825629_1_69338
preparationPreviousStandardDataResultComReqDto.setExtendedField5(circulationCollectionsRes.getExtendedField5());//SimpleFieldAssign//sourceId:1825563_1_69338
    }
if(obtainTargetBelongCycleComRespDto!=null){
      preparationPreviousStandardDataResultComReqDto.setCycleId(obtainTargetBelongCycleComRespDto.getPreviousCycleId());//SimpleFieldAssign//sourceId:1825507_1_69338
preparationPreviousStandardDataResultComReqDto.setEntityId(obtainTargetBelongCycleComRespDto.getLastEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1825512_1_69338
preparationPreviousStandardDataResultComReqDto.setBizRoleObjCode(obtainTargetBelongCycleComRespDto.getBizRoleObjCode());//SimpleFieldAssign//sourceId:1825511_1_69338
preparationPreviousStandardDataResultComReqDto.setBelongToPersonalIdentityId(obtainTargetBelongCycleComRespDto.getBelongToPersonalIdentityId());//SimpleFieldAssign//sourceId:1825514_1_69338
preparationPreviousStandardDataResultComReqDto.setExtendedField1(obtainTargetBelongCycleComRespDto.getCategoryTableTypeCode());//SimpleFieldAssign//sourceId:1825515_1_69338
preparationPreviousStandardDataResultComReqDto.setExtendedField2(obtainTargetBelongCycleComRespDto.getOneLevelCategoryId());//SimpleFieldAssign//sourceId:1825547_1_69338
preparationPreviousStandardDataResultComReqDto.setExtendedField3(obtainTargetBelongCycleComRespDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1825516_1_69338
preparationPreviousStandardDataResultComReqDto.setExtendedField4(obtainTargetBelongCycleComRespDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1825548_1_69338
    }
if(reqDto!=null){
      preparationPreviousStandardDataResultComReqDto.setThemeContentId(reqDto.getThemeContentId());//SimpleFieldAssign//sourceId:1825517_1_69338
    }

    /*D4准备上一更新周期标准数据结果(公共)[8542]   */
    Assert.isNull(preparationPreviousStandardDataResultComReqDto.getDataType(),"D4执行刷模板标准数据（运维）-D4准备上一更新周期标准数据结果(公共)-数据点类型不能为空",false);
//Assert.isNull(preparationPreviousStandardDataResultComReqDto.getEntityId(),"D4执行刷模板标准数据（运维）-D4准备上一更新周期标准数据结果(公共)-归属内容表主键ID不能为空",false);
Assert.isNull(preparationPreviousStandardDataResultComReqDto.getThemeContentId(),"D4执行刷模板标准数据（运维）-D4准备上一更新周期标准数据结果(公共)-主题内容ID不能为空",false);
      preparationPreviousStandardDataResultComRespDto = standardDataService.preparationPreviousStandardDataResultCom(preparationPreviousStandardDataResultComReqDto)/*vcase invoke isSameApp*/;



           }
CalculateDataPointIncDecMeasureAndAmplitudeComRespDto calculateDataPointIncDecMeasureAndAmplitudeComRespDto = null;
    if(preparationPreviousStandardDataResultComRespDto !=null){
          CalculateDataPointIncDecMeasureAndAmplitudeComReqDto calculateDataPointIncDecMeasureAndAmplitudeComReqDto=new CalculateDataPointIncDecMeasureAndAmplitudeComReqDto();
  if(preparationPreviousStandardDataResultComRespDto!=null){
      calculateDataPointIncDecMeasureAndAmplitudeComReqDto.setParentDataResult(preparationPreviousStandardDataResultComRespDto.getDataResultId()!=null?Double.valueOf(preparationPreviousStandardDataResultComRespDto.getDataResultId()):null);//SimpleFieldAssign//sourceId:1825555_1_69339
    }
if(circulationCollectionsRes!=null){
      calculateDataPointIncDecMeasureAndAmplitudeComReqDto.setDataResult(circulationCollectionsRes.getDataResult());//SimpleFieldAssign//sourceId:1825556_1_69339
    }

    /*D4计算数据点增降量与增降幅(公共)[8713]   */
    Assert.isNull(calculateDataPointIncDecMeasureAndAmplitudeComReqDto.getDataResult(),"D4执行刷模板标准数据（运维）-D4计算数据点增降量与增降幅(公共)-数据值结果不能为空",false);
      calculateDataPointIncDecMeasureAndAmplitudeComRespDto = targetCalcService.calculateDataPointIncDecMeasureAndAmplitudeCom(calculateDataPointIncDecMeasureAndAmplitudeComReqDto)/*vcase invoke isSameApp*/;



           }
PreparationPreviousStandardDataResultComRespDto preparationPreviousStandardDataResultComRespDto_2 = null;
    if(obtainTargetBelongCycleComRespDto !=null){
          PreparationPreviousStandardDataResultComReqDto preparationPreviousStandardDataResultComReqDto_1=new PreparationPreviousStandardDataResultComReqDto();
  if(circulationCollectionsRes!=null){
      preparationPreviousStandardDataResultComReqDto_1.setDataType(circulationCollectionsRes.getDataType());//SimpleFieldAssign//sourceId:1825508_1_69340
preparationPreviousStandardDataResultComReqDto_1.setEntityId(circulationCollectionsRes.getEntityId());//SimpleFieldAssign//sourceId:1825512_1_69340
preparationPreviousStandardDataResultComReqDto_1.setBelongToPersonalIdentityId(circulationCollectionsRes.getBelongToPersonalIdentityId());//SimpleFieldAssign//sourceId:1825514_1_69340
preparationPreviousStandardDataResultComReqDto_1.setAccountId(circulationCollectionsRes.getAccountId());//SimpleFieldAssign//sourceId:1825629_1_69340
preparationPreviousStandardDataResultComReqDto_1.setExtendedField5(circulationCollectionsRes.getExtendedField5());//SimpleFieldAssign//sourceId:1825563_1_69340
    }
if(obtainTargetBelongCycleComRespDto!=null){
      preparationPreviousStandardDataResultComReqDto_1.setCycleId(obtainTargetBelongCycleComRespDto.getPreviousCycleId());//SimpleFieldAssign//sourceId:1825507_1_69340
preparationPreviousStandardDataResultComReqDto_1.setBizRoleObjCode(obtainTargetBelongCycleComRespDto.getBizRoleObjCode());//SimpleFieldAssign//sourceId:1825511_1_69340
preparationPreviousStandardDataResultComReqDto_1.setExtendedField1(obtainTargetBelongCycleComRespDto.getCategoryTableTypeCode());//SimpleFieldAssign//sourceId:1825515_1_69340
preparationPreviousStandardDataResultComReqDto_1.setExtendedField2(obtainTargetBelongCycleComRespDto.getOneLevelCategoryId());//SimpleFieldAssign//sourceId:1825547_1_69340
preparationPreviousStandardDataResultComReqDto_1.setExtendedField3(obtainTargetBelongCycleComRespDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1825516_1_69340
preparationPreviousStandardDataResultComReqDto_1.setExtendedField4(obtainTargetBelongCycleComRespDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1825548_1_69340
    }
if(reqDto!=null){
      preparationPreviousStandardDataResultComReqDto_1.setThemeContentId(reqDto.getThemeContentId());//SimpleFieldAssign//sourceId:1825517_1_69340
    }

    /*D4准备上一更新周期标准数据结果(公共)[8542]   */
    Assert.isNull(preparationPreviousStandardDataResultComReqDto_1.getDataType(),"D4执行刷模板标准数据（运维）-D4准备上一更新周期标准数据结果(公共)-数据点类型不能为空",false);
//Assert.isNull(preparationPreviousStandardDataResultComReqDto_1.getEntityId(),"D4执行刷模板标准数据（运维）-D4准备上一更新周期标准数据结果(公共)-归属内容表主键ID不能为空",false);
Assert.isNull(preparationPreviousStandardDataResultComReqDto_1.getThemeContentId(),"D4执行刷模板标准数据（运维）-D4准备上一更新周期标准数据结果(公共)-主题内容ID不能为空",false);
      preparationPreviousStandardDataResultComRespDto_2 = standardDataService.preparationPreviousStandardDataResultCom(preparationPreviousStandardDataResultComReqDto_1)/*vcase invoke isSameApp*/;



           }
CalculateDataPointIncDecMeasureAndAmplitudeComRespDto calculateDataPointIncDecMeasureAndAmplitudeComRespDto_2 = null;
    if(preparationPreviousStandardDataResultComRespDto_2 !=null){
          CalculateDataPointIncDecMeasureAndAmplitudeComReqDto calculateDataPointIncDecMeasureAndAmplitudeComReqDto_1=new CalculateDataPointIncDecMeasureAndAmplitudeComReqDto();
  if(preparationPreviousStandardDataResultComRespDto_2!=null){
      calculateDataPointIncDecMeasureAndAmplitudeComReqDto_1.setParentDataResult(preparationPreviousStandardDataResultComRespDto_2.getDataResult());//SimpleFieldAssign//sourceId:1825555_1_69341
    }
if(circulationCollectionsRes!=null){
      calculateDataPointIncDecMeasureAndAmplitudeComReqDto_1.setDataResult(circulationCollectionsRes.getDataResult());//SimpleFieldAssign//sourceId:1825556_1_69341
    }

    /*D4计算数据点增降量与增降幅(公共)[8713]   */
    Assert.isNull(calculateDataPointIncDecMeasureAndAmplitudeComReqDto_1.getDataResult(),"D4执行刷模板标准数据（运维）-D4计算数据点增降量与增降幅(公共)-数据值结果不能为空",false);
      calculateDataPointIncDecMeasureAndAmplitudeComRespDto_2 = targetCalcService.calculateDataPointIncDecMeasureAndAmplitudeCom(calculateDataPointIncDecMeasureAndAmplitudeComReqDto_1)/*vcase invoke isSameApp*/;



           }
boolean bOOLEAN ;
    if(preparationPreviousStandardDataResultComRespDto !=null&&calculateDataPointIncDecMeasureAndAmplitudeComRespDto !=null&&preparationPreviousStandardDataResultComRespDto_2 !=null&&calculateDataPointIncDecMeasureAndAmplitudeComRespDto_2 !=null&&obtainTargetBelongCycleComRespDto !=null){
          OmsStandardDataResult omsStandardDataResult=new OmsStandardDataResult();
  if(circulationCollectionsRes!=null){
      omsStandardDataResult.setDataResultId(circulationCollectionsRes.getDataResultId());//SimpleFieldAssign//sourceId:1825464_1_69337
    }
if(preparationPreviousStandardDataResultComRespDto!=null){
      omsStandardDataResult.setParentDataResultId(preparationPreviousStandardDataResultComRespDto.getDataResultId());//SimpleFieldAssign//sourceId:1825493_1_69337
omsStandardDataResult.setParentDataResult(preparationPreviousStandardDataResultComRespDto.getDataResult());//SimpleFieldAssign//sourceId:1825494_1_69337
    }
if(calculateDataPointIncDecMeasureAndAmplitudeComRespDto!=null){
      omsStandardDataResult.setChangeFromLastValue(calculateDataPointIncDecMeasureAndAmplitudeComRespDto.getChangeFromLastValue());//SimpleFieldAssign//sourceId:1825495_1_69337
omsStandardDataResult.setChangeFromLastRatio(calculateDataPointIncDecMeasureAndAmplitudeComRespDto.getChangeFromLastRatio());//SimpleFieldAssign//sourceId:1825496_1_69337
    }
if(preparationPreviousStandardDataResultComRespDto_2!=null){
      omsStandardDataResult.setUpdateCycleParentDataResultId(preparationPreviousStandardDataResultComRespDto_2.getDataResultId());//SimpleFieldAssign//sourceId:1825568_1_69337
omsStandardDataResult.setUpdateCycleParentDataResult(preparationPreviousStandardDataResultComRespDto_2.getDataResult());//SimpleFieldAssign//sourceId:1825569_1_69337
    }
if(calculateDataPointIncDecMeasureAndAmplitudeComRespDto_2!=null){
      omsStandardDataResult.setUpdateCycleChangeFromLastValue(calculateDataPointIncDecMeasureAndAmplitudeComRespDto_2.getChangeFromLastValue());//SimpleFieldAssign//sourceId:1825570_1_69337
omsStandardDataResult.setUpdateCycleChangeFromLastRatio(calculateDataPointIncDecMeasureAndAmplitudeComRespDto_2.getChangeFromLastRatio());//SimpleFieldAssign//sourceId:1825571_1_69337
    }
if(obtainTargetBelongCycleComRespDto!=null){
      omsStandardDataResult.setStandardDataCalcCycleModel(obtainTargetBelongCycleComRespDto.getStandardDataCalcCycleModel());//SimpleFieldAssign//sourceId:1825497_1_69337
omsStandardDataResult.setParentSubMidCycleType(obtainTargetBelongCycleComRespDto.getParentSubMidCycleType());//SimpleFieldAssign//sourceId:1825498_1_69337
omsStandardDataResult.setExtendedField3(obtainTargetBelongCycleComRespDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1825499_1_69337
omsStandardDataResult.setExtendedField4(obtainTargetBelongCycleComRespDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1825500_1_69337
omsStandardDataResult.setBelongToPersonalIdentityRoleCode(obtainTargetBelongCycleComRespDto.getBizRoleObjCode());//SimpleFieldAssign//sourceId:1825501_1_69337
    }

    /*4-01-01修改标准数据[2860]   */
    Assert.isNull(omsStandardDataResult.getDataResultId(),"D4执行刷模板标准数据（运维）-4-01-01修改标准数据-数据结果ID 不能为空",false);
Assert.isNull(omsStandardDataResult.getStandardDataCalcCycleModel(),"D4执行刷模板标准数据（运维）-4-01-01修改标准数据-计算周期五模型不能为空",false);
Assert.isNull(omsStandardDataResult.getParentSubMidCycleType(),"D4执行刷模板标准数据（运维）-4-01-01修改标准数据-父子中周期类型不能为空",false);
Assert.isNull(omsStandardDataResult.getExtendedField3(),"D4执行刷模板标准数据（运维）-4-01-01修改标准数据-扩展字段3不能为空",false);
Assert.isNull(omsStandardDataResult.getExtendedField4(),"D4执行刷模板标准数据（运维）-4-01-01修改标准数据-扩展字段4不能为空",false);
      bOOLEAN = mOmsStandardDataResultService.updateStandardData(omsStandardDataResult)/*vcase invoke 本地 method 方法调用;*/;



           }
//ModelCode: circulationEnd
        }

      }
ImplementBrushTempStandardDataRespDto retData = new ImplementBrushTempStandardDataRespDto();





return retData;
  }
/**
   * D4执行修复已产生的标准数据(公共)[9790]
   * gen by moon at 6/13/2024, 4:38:45 PM
   */
  @Trace(operationName = "D4执行修复已产生的标准数据(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementRepairTheGeneratedStandardDataComRespDto implementRepairTheGeneratedStandardDataCom(ImplementRepairTheGeneratedStandardDataComReqDto reqDto){


      //virtualUsage D3分析公共字段(公共)  69938
      AnalysisCommonDataComRespDto analysisCommonDataComRespDto = null;
    AnalysisCommonDataComReqDto analysisCommonDataComReqDto=new AnalysisCommonDataComReqDto();
  if(reqDto!=null){
      analysisCommonDataComReqDto.setEventBatchUpdateCode(reqDto.getEventBatchUpdateCode());//SimpleFieldAssign//sourceId:1864739_1_69938
analysisCommonDataComReqDto.setCalcStartTime(reqDto.getCalcStartTime());//SimpleFieldAssign//sourceId:1864740_1_69938
analysisCommonDataComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1864741_1_69938
    }

    /*D3分析公共字段(公共)[9793]   */
    Assert.isNull(analysisCommonDataComReqDto.getEvaluationTemplateId(),"D4执行修复已产生的标准数据(公共)-D3分析公共字段(公共)-冗余评价模板ID不能为空",false);
      analysisCommonDataComRespDto = fwAppSystemTestDomainClient.analysisCommonDataCom(analysisCommonDataComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



//virtualUsage D3查目标归属周期详情(公共)  69930
      QueryTargetBeCycleDetailComRespDto queryTargetBeCycleDetailComRespDto = null;
    QueryTargetBeCycleDetailComReqDto queryTargetBeCycleDetailComReqDto=new QueryTargetBeCycleDetailComReqDto();
  if(reqDto!=null){
      queryTargetBeCycleDetailComReqDto.setCycleId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:1864128_1_69930
queryTargetBeCycleDetailComReqDto.setEntityId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:1864129_1_69930
queryTargetBeCycleDetailComReqDto.setParentSubMidCycleType(reqDto.getParentSubMidCycleType());//SimpleFieldAssign//sourceId:1864130_1_69930
queryTargetBeCycleDetailComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1864131_1_69930
    }

    /*D3查目标归属周期详情(公共)[9544]   */
    Assert.isNull(queryTargetBeCycleDetailComReqDto.getCycleId(),"D4执行修复已产生的标准数据(公共)-D3查目标归属周期详情(公共)-归属周期ID不能为空",false);
Assert.isNull(queryTargetBeCycleDetailComReqDto.getEntityId(),"D4执行修复已产生的标准数据(公共)-D3查目标归属周期详情(公共)-归属内容表主键ID不能为空",false);
Assert.isNull(queryTargetBeCycleDetailComReqDto.getParentSubMidCycleType(),"D4执行修复已产生的标准数据(公共)-D3查目标归属周期详情(公共)-父子中过程周期类型不能为空",false);
Assert.isNull(queryTargetBeCycleDetailComReqDto.getEvaluationTemplateId(),"D4执行修复已产生的标准数据(公共)-D3查目标归属周期详情(公共)-冗余评价模板ID不能为空",false);
      queryTargetBeCycleDetailComRespDto = fwAppTargetCalcClient.queryTargetBeCycleDetailCom(queryTargetBeCycleDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



//virtualUsage D4分析修复标准数据填报责任人对象ID(公共)  69946
      AnalysisRepairStandardPersonLiableObjIdComRespDto analysisRepairStandardPersonLiableObjIdComRespDto = null;
    if(queryTargetBeCycleDetailComRespDto !=null){
          AnalysisRepairStandardPersonLiableObjIdComReqDto analysisRepairStandardPersonLiableObjIdComReqDto=new AnalysisRepairStandardPersonLiableObjIdComReqDto();
  if(reqDto!=null){
      analysisRepairStandardPersonLiableObjIdComReqDto.setDataType(reqDto.getDataType());//SimpleFieldAssign//sourceId:1865270_1_69946
analysisRepairStandardPersonLiableObjIdComReqDto.setBelongToContentId(reqDto.getBelongToContentId());//SimpleFieldAssign//sourceId:1865286_1_69946
analysisRepairStandardPersonLiableObjIdComReqDto.setBizRoleObjCode(reqDto.getBizRoleObjCode());//SimpleFieldAssign//sourceId:1865287_1_69946
analysisRepairStandardPersonLiableObjIdComReqDto.setPersonLiableObjStanddardId(reqDto.getPersonLiableObjId());//SimpleFieldAssign//sourceId:1865279_1_69946
    }
if(queryTargetBeCycleDetailComRespDto!=null){
      analysisRepairStandardPersonLiableObjIdComReqDto.setPersonLiableObjId(queryTargetBeCycleDetailComRespDto.getPersonLiableObjId());//SimpleFieldAssign//sourceId:1865271_1_69946
    }

    /*D4分析修复标准数据填报责任人对象ID(公共)[9799]   */
    Assert.isNull(analysisRepairStandardPersonLiableObjIdComReqDto.getDataType(),"D4执行修复已产生的标准数据(公共)-D4分析修复标准数据填报责任人对象ID(公共)-数据点类型不能为空",false);
Assert.isNull(analysisRepairStandardPersonLiableObjIdComReqDto.getBelongToContentId(),"D4执行修复已产生的标准数据(公共)-D4分析修复标准数据填报责任人对象ID(公共)-数据归属内容表主键ID不能为空",false);
Assert.isNull(analysisRepairStandardPersonLiableObjIdComReqDto.getPersonLiableObjId(),"D4执行修复已产生的标准数据(公共)-D4分析修复标准数据填报责任人对象ID(公共)-填报评价责任人对象ID不能为空",false);
Assert.isNull(analysisRepairStandardPersonLiableObjIdComReqDto.getBizRoleObjCode(),"D4执行修复已产生的标准数据(公共)-D4分析修复标准数据填报责任人对象ID(公共)-填报评价责任人业务角色标识不能为空",false);
Assert.isNull(analysisRepairStandardPersonLiableObjIdComReqDto.getPersonLiableObjStanddardId(),"D4执行修复已产生的标准数据(公共)-D4分析修复标准数据填报责任人对象ID(公共)-标准数据报评价责任人对象ID不能为空",false);
      analysisRepairStandardPersonLiableObjIdComRespDto = analysisRepairStandardPersonLiableObjIdCom(analysisRepairStandardPersonLiableObjIdComReqDto)/*vcase invoke 同服务,同domain*/;



           }
//virtualUsage D3-查询上一个执行周期的周期及目标周期详情(公共)  69940
      QueryLastExecCycleAndTargetCycleDetailComRespDto queryLastExecCycleAndTargetCycleDetailComRespDto = null;
    QueryLastExecCycleAndTargetCycleDetailComReqDto queryLastExecCycleAndTargetCycleDetailComReqDto=new QueryLastExecCycleAndTargetCycleDetailComReqDto();
  if(reqDto!=null){
      queryLastExecCycleAndTargetCycleDetailComReqDto.setCycleId(reqDto.getUpdateCycleId());//SimpleFieldAssign//sourceId:1865109_1_69940
queryLastExecCycleAndTargetCycleDetailComReqDto.setEvaObjTargetCycleId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:1865108_1_69940
queryLastExecCycleAndTargetCycleDetailComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1865110_1_69940
    }

    /*D3-查询上一个执行周期的周期及目标周期详情(公共)[7507]   */
    Assert.isNull(queryLastExecCycleAndTargetCycleDetailComReqDto.getCycleId(),"D4执行修复已产生的标准数据(公共)-D3-查询上一个执行周期的周期及目标周期详情(公共)-周期ID不能为空",false);
Assert.isNull(queryLastExecCycleAndTargetCycleDetailComReqDto.getEvaObjTargetCycleId(),"D4执行修复已产生的标准数据(公共)-D3-查询上一个执行周期的周期及目标周期详情(公共)-被评对象目标周期ID不能为空",false);
Assert.isNull(queryLastExecCycleAndTargetCycleDetailComReqDto.getEvaluationTemplateId(),"D4执行修复已产生的标准数据(公共)-D3-查询上一个执行周期的周期及目标周期详情(公共)-冗余评价模板ID不能为空",false);
      queryLastExecCycleAndTargetCycleDetailComRespDto = fwAppExecuteCycleClient.queryLastExecCycleAndTargetCycleDetailCom(queryLastExecCycleAndTargetCycleDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



//virtualUsage D4分析修复标准数据上一周期相关数据(公共)  69939
      AnalysisRepairStandardPreDataComRespDto analysisRepairStandardPreDataComRespDto = null;
    if(queryTargetBeCycleDetailComRespDto !=null&&queryLastExecCycleAndTargetCycleDetailComRespDto !=null){
          AnalysisRepairStandardPreDataComReqDto analysisRepairStandardPreDataComReqDto=new AnalysisRepairStandardPreDataComReqDto();
  if(reqDto!=null){
      analysisRepairStandardPreDataComReqDto.setDataResult(reqDto.getDataResult());//SimpleFieldAssign//sourceId:1865012_1_69939
analysisRepairStandardPreDataComReqDto.setDataType(reqDto.getDataType());//SimpleFieldAssign//sourceId:1864992_1_69939
analysisRepairStandardPreDataComReqDto.setEntityId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:1864993_1_69939
analysisRepairStandardPreDataComReqDto.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1864994_1_69939
    }
if(queryTargetBeCycleDetailComRespDto!=null){
      analysisRepairStandardPreDataComReqDto.setPreviousCycleId(queryTargetBeCycleDetailComRespDto.getPreviousCycleId());//SimpleFieldAssign//sourceId:1865014_1_69939
analysisRepairStandardPreDataComReqDto.setLastEvaObjTargetCycleId(queryTargetBeCycleDetailComRespDto.getLastEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1865013_1_69939
analysisRepairStandardPreDataComReqDto.setBizRoleObjCode(queryTargetBeCycleDetailComRespDto.getBizRoleObjCode());//SimpleFieldAssign//sourceId:1864995_1_69939
analysisRepairStandardPreDataComReqDto.setBelongToPersonalIdentityRoleCode(queryTargetBeCycleDetailComRespDto.getBizRoleObjCode());//SimpleFieldAssign//sourceId:1864996_1_69939
analysisRepairStandardPreDataComReqDto.setBelongToPersonalIdentityId(queryTargetBeCycleDetailComRespDto.getBelongToPersonalIdentityId());//SimpleFieldAssign//sourceId:1864997_1_69939
analysisRepairStandardPreDataComReqDto.setExtendedField3(queryTargetBeCycleDetailComRespDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1865001_1_69939
analysisRepairStandardPreDataComReqDto.setExtendedField4(queryTargetBeCycleDetailComRespDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1865002_1_69939
    }
if(queryLastExecCycleAndTargetCycleDetailComRespDto!=null){
      analysisRepairStandardPreDataComReqDto.setPreUpdateCycleId(queryLastExecCycleAndTargetCycleDetailComRespDto.getLastCycleId());//SimpleFieldAssign//sourceId:1865015_1_69939
    }

    /*D4分析修复标准数据上一周期相关数据(公共)[9794]   */
    Assert.isNull(analysisRepairStandardPreDataComReqDto.getDataResult(),"D4执行修复已产生的标准数据(公共)-D4分析修复标准数据上一周期相关数据(公共)-数据值结果不能为空",false);
Assert.isNull(analysisRepairStandardPreDataComReqDto.getDataType(),"D4执行修复已产生的标准数据(公共)-D4分析修复标准数据上一周期相关数据(公共)-数据点类型不能为空",false);
Assert.isNull(analysisRepairStandardPreDataComReqDto.getEntityId(),"D4执行修复已产生的标准数据(公共)-D4分析修复标准数据上一周期相关数据(公共)-归属内容表主键ID不能为空",false);
Assert.isNull(analysisRepairStandardPreDataComReqDto.getThemeContentId(),"D4执行修复已产生的标准数据(公共)-D4分析修复标准数据上一周期相关数据(公共)-主题内容ID不能为空",false);
Assert.isNull(analysisRepairStandardPreDataComReqDto.getBizRoleObjCode(),"D4执行修复已产生的标准数据(公共)-D4分析修复标准数据上一周期相关数据(公共)-填报评价责任人业务角色标识不能为空",false);
Assert.isNull(analysisRepairStandardPreDataComReqDto.getBelongToPersonalIdentityRoleCode(),"D4执行修复已产生的标准数据(公共)-D4分析修复标准数据上一周期相关数据(公共)-数据归属对象角色编码不能为空",false);
Assert.isNull(analysisRepairStandardPreDataComReqDto.getBelongToPersonalIdentityId(),"D4执行修复已产生的标准数据(公共)-D4分析修复标准数据上一周期相关数据(公共)-数据归属对象ID不能为空",false);
Assert.isNull(analysisRepairStandardPreDataComReqDto.getExtendedField3(),"D4执行修复已产生的标准数据(公共)-D4分析修复标准数据上一周期相关数据(公共)-扩展字段3不能为空",false);
Assert.isNull(analysisRepairStandardPreDataComReqDto.getExtendedField4(),"D4执行修复已产生的标准数据(公共)-D4分析修复标准数据上一周期相关数据(公共)-扩展字段4不能为空",false);
      analysisRepairStandardPreDataComRespDto = analysisRepairStandardPreDataCom(analysisRepairStandardPreDataComReqDto)/*vcase invoke 同服务,同domain*/;



           }
//virtualUsage D4-1修改标准数据(公共)  69932
      UpdateStandardDataComRespDto updateStandardDataComRespDto = null;
    if(analysisRepairStandardPreDataComRespDto !=null&&analysisCommonDataComRespDto !=null&&queryTargetBeCycleDetailComRespDto !=null&&analysisRepairStandardPersonLiableObjIdComRespDto !=null){
          UpdateStandardDataComReqDto updateStandardDataComReqDto=new UpdateStandardDataComReqDto();
  if(reqDto!=null){
      updateStandardDataComReqDto.setDataResultId(reqDto.getDataResultId());//SimpleFieldAssign//sourceId:1864118_1_69932
    }
if(analysisRepairStandardPreDataComRespDto!=null){
      updateStandardDataComReqDto.setParentDataResultId(analysisRepairStandardPreDataComRespDto.getParentDataResultId());//SimpleFieldAssign//sourceId:1864709_1_69932
updateStandardDataComReqDto.setParentDataResult(analysisRepairStandardPreDataComRespDto.getParentDataResult());//SimpleFieldAssign//sourceId:1864710_1_69932
updateStandardDataComReqDto.setChangeFromLastValue(analysisRepairStandardPreDataComRespDto.getChangeFromLastValue());//SimpleFieldAssign//sourceId:1864711_1_69932
updateStandardDataComReqDto.setChangeFromLastRatio(analysisRepairStandardPreDataComRespDto.getChangeFromLastRatio());//SimpleFieldAssign//sourceId:1864712_1_69932
updateStandardDataComReqDto.setUpdateCycleParentDataResultId(analysisRepairStandardPreDataComRespDto.getUpdateCycleParentDataResultId());//SimpleFieldAssign//sourceId:1864713_1_69932
updateStandardDataComReqDto.setUpdateCycleParentDataResult(analysisRepairStandardPreDataComRespDto.getUpdateCycleParentDataResult());//SimpleFieldAssign//sourceId:1864714_1_69932
updateStandardDataComReqDto.setUpdateCycleChangeFromLastValue(analysisRepairStandardPreDataComRespDto.getUpdateCycleChangeFromLastValue());//SimpleFieldAssign//sourceId:1864715_1_69932
updateStandardDataComReqDto.setUpdateCycleChangeFromLastRatio(analysisRepairStandardPreDataComRespDto.getUpdateCycleChangeFromLastRatio());//SimpleFieldAssign//sourceId:1864716_1_69932
    }
if(analysisCommonDataComRespDto!=null){
      updateStandardDataComReqDto.setEventBatchUpdateCode(analysisCommonDataComRespDto.getEventBatchUpdateCode());//SimpleFieldAssign//sourceId:1864233_1_69932
updateStandardDataComReqDto.setCalcStartTime(analysisCommonDataComRespDto.getCalcStartTime());//SimpleFieldAssign//sourceId:1864234_1_69932
    }
if(queryTargetBeCycleDetailComRespDto!=null){
      updateStandardDataComReqDto.setIsWorkCycleData(queryTargetBeCycleDetailComRespDto.getIsWorkCycleData());//SimpleFieldAssign//sourceId:1864127_1_69932
updateStandardDataComReqDto.setExtendedField3(queryTargetBeCycleDetailComRespDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1864124_1_69932
updateStandardDataComReqDto.setExtendedField4(queryTargetBeCycleDetailComRespDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1864125_1_69932
updateStandardDataComReqDto.setBelongToPersonalIdentityTypeCode(queryTargetBeCycleDetailComRespDto.getBelongToPersonalIdentityTypeCode());//SimpleFieldAssign//sourceId:1864120_1_69932
updateStandardDataComReqDto.setBelongToPersonalIdentityRoleCode(queryTargetBeCycleDetailComRespDto.getBizRoleObjCode());//SimpleFieldAssign//sourceId:1864126_1_69932
updateStandardDataComReqDto.setBelongToPersonalIdentityId(queryTargetBeCycleDetailComRespDto.getBelongToPersonalIdentityId());//SimpleFieldAssign//sourceId:1864121_1_69932
    }
if(analysisRepairStandardPersonLiableObjIdComRespDto!=null){
      updateStandardDataComReqDto.setPersonLiableObjId(analysisRepairStandardPersonLiableObjIdComRespDto.getPersonLiableObjId());//SimpleFieldAssign//sourceId:1864235_1_69932
    }

    /*D4-1修改标准数据(公共)[3047]   */
    Assert.isNull(updateStandardDataComReqDto.getDataResultId(),"D4执行修复已产生的标准数据(公共)-D4-1修改标准数据(公共)-数据结果ID 不能为空",false);
Assert.isNull(updateStandardDataComReqDto.getIsWorkCycleData(),"D4执行修复已产生的标准数据(公共)-D4-1修改标准数据(公共)-是否工作周期数据不能为空",false);
Assert.isNull(updateStandardDataComReqDto.getExtendedField3(),"D4执行修复已产生的标准数据(公共)-D4-1修改标准数据(公共)-扩展字段3不能为空",false);
Assert.isNull(updateStandardDataComReqDto.getExtendedField4(),"D4执行修复已产生的标准数据(公共)-D4-1修改标准数据(公共)-扩展字段4不能为空",false);
//Assert.isNull(updateStandardDataComReqDto.getPersonLiableObjId(),"D4执行修复已产生的标准数据(公共)-D4-1修改标准数据(公共)-填报评价责任人对象ID不能为空",false);
Assert.isNull(updateStandardDataComReqDto.getBelongToPersonalIdentityTypeCode(),"D4执行修复已产生的标准数据(公共)-D4-1修改标准数据(公共)-数据归属对象类型编码不能为空",false);
Assert.isNull(updateStandardDataComReqDto.getBelongToPersonalIdentityRoleCode(),"D4执行修复已产生的标准数据(公共)-D4-1修改标准数据(公共)-数据归属对象角色编码不能为空",false);
Assert.isNull(updateStandardDataComReqDto.getBelongToPersonalIdentityId(),"D4执行修复已产生的标准数据(公共)-D4-1修改标准数据(公共)-数据归属对象ID不能为空",false);
      updateStandardDataComRespDto = standardDataService.updateStandardDataCom(updateStandardDataComReqDto)/*vcase invoke isSameApp*/;



           }
ImplementRepairTheGeneratedStandardDataComRespDto retData = new ImplementRepairTheGeneratedStandardDataComRespDto();





return retData;
  }
/**
   * D4分析修复标准数据上一周期相关数据(公共)[9794]
   * gen by moon at 6/13/2024, 4:38:47 PM
   */
  @Trace(operationName = "D4分析修复标准数据上一周期相关数据(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public AnalysisRepairStandardPreDataComRespDto analysisRepairStandardPreDataCom(AnalysisRepairStandardPreDataComReqDto reqDto){


      ImplementCalcReceivingField005RespDto receptionServiceRes_2 =null;
//步骤0: M4执行计算接收字段001（特殊方法） - implementCalcReceivingField001
     //ModelCode: receptionService
        ImplementCalcReceivingField001RespDto receptionServiceRes = null;
    ImplementCalcReceivingField001ReqDto receptionServiceReq=new ImplementCalcReceivingField001ReqDto();
  if(reqDto!=null){
      receptionServiceReq.setDataResult(reqDto.getDataResult());//SimpleFieldAssign//sourceId:1864979_1
receptionServiceReq.setDataType(reqDto.getDataType());//SimpleFieldAssign//sourceId:1864863_1
receptionServiceReq.setLastEvaObjTargetCycleId(reqDto.getLastEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1864986_1
receptionServiceReq.setPreviousCycleId(reqDto.getPreviousCycleId());//SimpleFieldAssign//sourceId:1864987_1
receptionServiceReq.setPreUpdateCycleId(reqDto.getPreUpdateCycleId());//SimpleFieldAssign//sourceId:1864988_1
receptionServiceReq.setEntityId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:1864865_1
receptionServiceReq.setThemeContentId(reqDto.getThemeContentId());//SimpleFieldAssign//sourceId:1864866_1
receptionServiceReq.setBizRoleObjCode(reqDto.getBizRoleObjCode());//SimpleFieldAssign//sourceId:1864867_1
receptionServiceReq.setBelongToPersonalIdentityRoleCode(reqDto.getBelongToPersonalIdentityRoleCode());//SimpleFieldAssign//sourceId:1864869_1
receptionServiceReq.setBelongToPersonalIdentityId(reqDto.getBelongToPersonalIdentityId());//SimpleFieldAssign//sourceId:1864868_1
receptionServiceReq.setAccountId(reqDto.getAccountId());//SimpleFieldAssign//sourceId:1864870_1
receptionServiceReq.setExtendedField1(reqDto.getExtendedField1());//SimpleFieldAssign//sourceId:1864874_1
receptionServiceReq.setExtendedField2(reqDto.getExtendedField2());//SimpleFieldAssign//sourceId:1864871_1
receptionServiceReq.setExtendedField3(reqDto.getExtendedField3());//SimpleFieldAssign//sourceId:1864875_1
receptionServiceReq.setExtendedField4(reqDto.getExtendedField4());//SimpleFieldAssign//sourceId:1864872_1
receptionServiceReq.setExtendedField5(reqDto.getExtendedField5());//SimpleFieldAssign//sourceId:1864873_1
    }

    /*M4接收入参字段[9535]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq.getDataResult(),"D4分析修复标准数据上一周期相关数据(公共)-M4接收入参字段-数据值结果不能为空",false);
Assert.isNull(receptionServiceReq.getDataType(),"D4分析修复标准数据上一周期相关数据(公共)-M4接收入参字段-数据点类型不能为空",false);
      receptionServiceRes = nbSystemTestDomain.implementCalcReceivingField001(receptionServiceReq);




//步骤1: D4准备上一标准数据结果(公共) - preparationPreviousStandardDataResultCom
     PreparationPreviousStandardDataResultComRespDto preparationPreviousStandardDataResultComRespDto = null;
    PreparationPreviousStandardDataResultComReqDto preparationPreviousStandardDataResultComReqDto=new PreparationPreviousStandardDataResultComReqDto();
  if(reqDto!=null){
      preparationPreviousStandardDataResultComReqDto.setDataType(reqDto.getDataType());//SimpleFieldAssign//sourceId:1864826_1
preparationPreviousStandardDataResultComReqDto.setCycleId(reqDto.getPreviousCycleId());//SimpleFieldAssign//sourceId:1864825_1
preparationPreviousStandardDataResultComReqDto.setEntityId(reqDto.getLastEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1864830_1
preparationPreviousStandardDataResultComReqDto.setThemeContentId(reqDto.getThemeContentId());//SimpleFieldAssign//sourceId:1864835_1
preparationPreviousStandardDataResultComReqDto.setBizRoleObjCode(reqDto.getBizRoleObjCode());//SimpleFieldAssign//sourceId:1864829_1
preparationPreviousStandardDataResultComReqDto.setBelongToPersonalIdentityRoleCode(reqDto.getBelongToPersonalIdentityRoleCode());//SimpleFieldAssign//sourceId:1864831_1
preparationPreviousStandardDataResultComReqDto.setBelongToPersonalIdentityId(reqDto.getBelongToPersonalIdentityId());//SimpleFieldAssign//sourceId:1864832_1
preparationPreviousStandardDataResultComReqDto.setAccountId(reqDto.getAccountId());//SimpleFieldAssign//sourceId:1864839_1
preparationPreviousStandardDataResultComReqDto.setExtendedField1(reqDto.getExtendedField1());//SimpleFieldAssign//sourceId:1864833_1
preparationPreviousStandardDataResultComReqDto.setExtendedField2(reqDto.getExtendedField2());//SimpleFieldAssign//sourceId:1864836_1
preparationPreviousStandardDataResultComReqDto.setExtendedField3(reqDto.getExtendedField3());//SimpleFieldAssign//sourceId:1864834_1
preparationPreviousStandardDataResultComReqDto.setExtendedField4(reqDto.getExtendedField4());//SimpleFieldAssign//sourceId:1864837_1
preparationPreviousStandardDataResultComReqDto.setExtendedField5(reqDto.getExtendedField5());//SimpleFieldAssign//sourceId:1864838_1
    }

    /*D4准备上一归属标准数据结果(公共)[8542]   */
    Assert.isNull(preparationPreviousStandardDataResultComReqDto.getDataType(),"D4分析修复标准数据上一周期相关数据(公共)-D4准备上一归属标准数据结果(公共)-数据点类型不能为空",false);
      preparationPreviousStandardDataResultComRespDto = standardDataService.preparationPreviousStandardDataResultCom(preparationPreviousStandardDataResultComReqDto)/*vcase invoke isSameApp*/;




//步骤2: D4计算数据点增降量与增降幅(公共) - calculateDataPointIncDecMeasureAndAmplitudeCom
     CalculateDataPointIncDecMeasureAndAmplitudeComRespDto calculateDataPointIncDecMeasureAndAmplitudeComRespDto = null;
    if(preparationPreviousStandardDataResultComRespDto !=null){
          CalculateDataPointIncDecMeasureAndAmplitudeComReqDto calculateDataPointIncDecMeasureAndAmplitudeComReqDto=new CalculateDataPointIncDecMeasureAndAmplitudeComReqDto();
  if(preparationPreviousStandardDataResultComRespDto!=null){
      calculateDataPointIncDecMeasureAndAmplitudeComReqDto.setParentDataResult(preparationPreviousStandardDataResultComRespDto.getDataResult());//SimpleFieldAssign//sourceId:1864840_1
    }
if(reqDto!=null){
      calculateDataPointIncDecMeasureAndAmplitudeComReqDto.setDataResult(reqDto.getDataResult());//SimpleFieldAssign//sourceId:1864841_1
    }

    /*D4计算归属数据点增降量与增降幅(公共)[8713]   */
    Assert.isNull(calculateDataPointIncDecMeasureAndAmplitudeComReqDto.getDataResult(),"D4分析修复标准数据上一周期相关数据(公共)-D4计算归属数据点增降量与增降幅(公共)-数据值结果不能为空",false);
      calculateDataPointIncDecMeasureAndAmplitudeComRespDto = targetCalcService.calculateDataPointIncDecMeasureAndAmplitudeCom(calculateDataPointIncDecMeasureAndAmplitudeComReqDto)/*vcase invoke isSameApp*/;



           }

//步骤3: D4准备上一标准数据结果(公共) - preparationPreviousStandardDataResultCom
     PreparationPreviousStandardDataResultComRespDto preparationPreviousStandardDataResultComRespDto_2 = null;
    PreparationPreviousStandardDataResultComReqDto preparationPreviousStandardDataResultComReqDto_1=new PreparationPreviousStandardDataResultComReqDto();
  if(reqDto!=null){
      preparationPreviousStandardDataResultComReqDto_1.setDataType(reqDto.getDataType());//SimpleFieldAssign//sourceId:1864845_1
preparationPreviousStandardDataResultComReqDto_1.setCycleId(reqDto.getPreUpdateCycleId());//SimpleFieldAssign//sourceId:1864844_1
preparationPreviousStandardDataResultComReqDto_1.setEntityId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:1864849_1
preparationPreviousStandardDataResultComReqDto_1.setThemeContentId(reqDto.getThemeContentId());//SimpleFieldAssign//sourceId:1864854_1
preparationPreviousStandardDataResultComReqDto_1.setBizRoleObjCode(reqDto.getBizRoleObjCode());//SimpleFieldAssign//sourceId:1864848_1
preparationPreviousStandardDataResultComReqDto_1.setBelongToPersonalIdentityRoleCode(reqDto.getBelongToPersonalIdentityRoleCode());//SimpleFieldAssign//sourceId:1864850_1
preparationPreviousStandardDataResultComReqDto_1.setBelongToPersonalIdentityId(reqDto.getBelongToPersonalIdentityId());//SimpleFieldAssign//sourceId:1864851_1
preparationPreviousStandardDataResultComReqDto_1.setAccountId(reqDto.getAccountId());//SimpleFieldAssign//sourceId:1864858_1
preparationPreviousStandardDataResultComReqDto_1.setExtendedField1(reqDto.getExtendedField1());//SimpleFieldAssign//sourceId:1864852_1
preparationPreviousStandardDataResultComReqDto_1.setExtendedField2(reqDto.getExtendedField2());//SimpleFieldAssign//sourceId:1864855_1
preparationPreviousStandardDataResultComReqDto_1.setExtendedField3(reqDto.getExtendedField3());//SimpleFieldAssign//sourceId:1864853_1
preparationPreviousStandardDataResultComReqDto_1.setExtendedField4(reqDto.getExtendedField4());//SimpleFieldAssign//sourceId:1864856_1
preparationPreviousStandardDataResultComReqDto_1.setExtendedField5(reqDto.getExtendedField5());//SimpleFieldAssign//sourceId:1864857_1
    }

    /*D4准备上一更新标准数据结果(公共)[8542]   */
    Assert.isNull(preparationPreviousStandardDataResultComReqDto_1.getDataType(),"D4分析修复标准数据上一周期相关数据(公共)-D4准备上一更新标准数据结果(公共)-数据点类型不能为空",false);
      preparationPreviousStandardDataResultComRespDto_2 = standardDataService.preparationPreviousStandardDataResultCom(preparationPreviousStandardDataResultComReqDto_1)/*vcase invoke isSameApp*/;




//步骤4: D4计算数据点增降量与增降幅(公共) - calculateDataPointIncDecMeasureAndAmplitudeCom
     CalculateDataPointIncDecMeasureAndAmplitudeComRespDto calculateDataPointIncDecMeasureAndAmplitudeComRespDto_2 = null;
    if(preparationPreviousStandardDataResultComRespDto_2 !=null){
          CalculateDataPointIncDecMeasureAndAmplitudeComReqDto calculateDataPointIncDecMeasureAndAmplitudeComReqDto_1=new CalculateDataPointIncDecMeasureAndAmplitudeComReqDto();
  if(preparationPreviousStandardDataResultComRespDto_2!=null){
      calculateDataPointIncDecMeasureAndAmplitudeComReqDto_1.setParentDataResult(preparationPreviousStandardDataResultComRespDto_2.getDataResult());//SimpleFieldAssign//sourceId:1864859_1
    }
if(reqDto!=null){
      calculateDataPointIncDecMeasureAndAmplitudeComReqDto_1.setDataResult(reqDto.getDataResult());//SimpleFieldAssign//sourceId:1864860_1
    }

    /*D4计算更新数据点增降量与增降幅(公共)[8713]   */
    Assert.isNull(calculateDataPointIncDecMeasureAndAmplitudeComReqDto_1.getDataResult(),"D4分析修复标准数据上一周期相关数据(公共)-D4计算更新数据点增降量与增降幅(公共)-数据值结果不能为空",false);
      calculateDataPointIncDecMeasureAndAmplitudeComRespDto_2 = targetCalcService.calculateDataPointIncDecMeasureAndAmplitudeCom(calculateDataPointIncDecMeasureAndAmplitudeComReqDto_1)/*vcase invoke isSameApp*/;



           }

//步骤5: M4执行计算接收字段005（特殊方法） - implementCalcReceivingField005
     //ModelCode: receptionService
        ImplementCalcReceivingField005RespDto receptionServiceRes_1 = null;
    if(preparationPreviousStandardDataResultComRespDto !=null){
          ImplementCalcReceivingField005ReqDto receptionServiceReq_1=new ImplementCalcReceivingField005ReqDto();
  if(preparationPreviousStandardDataResultComRespDto!=null){
      receptionServiceReq_1.setParentDataResultId(preparationPreviousStandardDataResultComRespDto.getDataResultId());//SimpleFieldAssign//sourceId:1864955_1
receptionServiceReq_1.setParentDataResult(preparationPreviousStandardDataResultComRespDto.getDataResult());//SimpleFieldAssign//sourceId:1864956_1
    }
if(calculateDataPointIncDecMeasureAndAmplitudeComRespDto!=null){
      receptionServiceReq_1.setChangeFromLastValue(calculateDataPointIncDecMeasureAndAmplitudeComRespDto.getChangeFromLastValue());//SimpleFieldAssign//sourceId:1864957_1
receptionServiceReq_1.setChangeFromLastRatio(calculateDataPointIncDecMeasureAndAmplitudeComRespDto.getChangeFromLastRatio());//SimpleFieldAssign//sourceId:1864958_1
    }
if(preparationPreviousStandardDataResultComRespDto_2!=null){
      receptionServiceReq_1.setUpdateCycleParentDataResultId(preparationPreviousStandardDataResultComRespDto_2.getDataResultId());//SimpleFieldAssign//sourceId:1864959_1
receptionServiceReq_1.setUpdateCycleParentDataResult(preparationPreviousStandardDataResultComRespDto_2.getDataResult());//SimpleFieldAssign//sourceId:1864960_1
    }
if(calculateDataPointIncDecMeasureAndAmplitudeComRespDto_2!=null){
      receptionServiceReq_1.setUpdateCycleChangeFromLastValue(calculateDataPointIncDecMeasureAndAmplitudeComRespDto_2.getChangeFromLastValue());//SimpleFieldAssign//sourceId:1864961_1
receptionServiceReq_1.setUpdateCycleChangeFromLastRatio(calculateDataPointIncDecMeasureAndAmplitudeComRespDto_2.getChangeFromLastRatio());//SimpleFieldAssign//sourceId:1864962_1
    }

    /*M4接收出参字段[9539]  用于特殊方法接收上游入参。 */

      receptionServiceRes_1 = nbSystemTestDomain.implementCalcReceivingField005(receptionServiceReq_1);


      receptionServiceRes_2 = receptionServiceRes_1;
           }

AnalysisRepairStandardPreDataComRespDto retData = new AnalysisRepairStandardPreDataComRespDto();
  if(receptionServiceRes_2!=null){
      retData.setParentDataResultId(receptionServiceRes_2.getParentDataResultId());//SimpleFieldAssign//sourceId:1864971_1
retData.setParentDataResult(receptionServiceRes_2.getParentDataResult());//SimpleFieldAssign//sourceId:1864972_1
retData.setChangeFromLastValue(receptionServiceRes_2.getChangeFromLastValue());//SimpleFieldAssign//sourceId:1864973_1
retData.setChangeFromLastRatio(receptionServiceRes_2.getChangeFromLastRatio());//SimpleFieldAssign//sourceId:1864974_1
retData.setUpdateCycleParentDataResultId(receptionServiceRes_2.getUpdateCycleParentDataResultId());//SimpleFieldAssign//sourceId:1864975_1
retData.setUpdateCycleParentDataResult(receptionServiceRes_2.getUpdateCycleParentDataResult());//SimpleFieldAssign//sourceId:1864976_1
retData.setUpdateCycleChangeFromLastValue(receptionServiceRes_2.getUpdateCycleChangeFromLastValue());//SimpleFieldAssign//sourceId:1864977_1
retData.setUpdateCycleChangeFromLastRatio(receptionServiceRes_2.getUpdateCycleChangeFromLastRatio());//SimpleFieldAssign//sourceId:1864978_1
    }




return retData;
  }
/**
   * D4执行修复标准数据(公共)[9795]
   * gen by moon at 6/17/2024, 12:33:28 AM
   */
  @Trace(operationName = "D4执行修复标准数据(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementRepairStandardDataComRespDto implementRepairStandardDataCom(ImplementRepairStandardDataComReqDto reqDto){


      //步骤0: D4查询修复标准数据列表(公共) - queryRepairStandardDataListCom
     QueryRepairStandardDataListComRespDto queryRepairStandardDataListComRespDto = null;
    QueryRepairStandardDataListComReqDto queryRepairStandardDataListComReqDto=new QueryRepairStandardDataListComReqDto();
  queryRepairStandardDataListComReqDto.setIsArchive("FALSE");//sourceId:1873936_1
  if(reqDto!=null){
      queryRepairStandardDataListComReqDto.setResultType(reqDto.getResultType());//SimpleFieldAssign//sourceId:1865404_1
queryRepairStandardDataListComReqDto.setDataType(reqDto.getDataType());//SimpleFieldAssign//sourceId:1865403_1
      queryRepairStandardDataListComReqDto.setThemeContentId(reqDto.getThemeContentId());//SimpleFieldAssign//sourceId:1865054_1
queryRepairStandardDataListComReqDto.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1865055_1
    }

    /*D4查询修复标准数据列表(公共)[9797]   */
    Assert.isNull(queryRepairStandardDataListComReqDto.getThemeContentId(),"D4执行修复标准数据(公共)-D4查询修复标准数据列表(公共)-主题内容ID不能为空",false);
Assert.isNull(queryRepairStandardDataListComReqDto.getIsArchive(),"D4执行修复标准数据(公共)-D4查询修复标准数据列表(公共)-是否存档不能为空",false);
Assert.isNull(queryRepairStandardDataListComReqDto.getSpaceId(),"D4执行修复标准数据(公共)-D4查询修复标准数据列表(公共)-创建于空间ID不能为空",false);
      queryRepairStandardDataListComRespDto = queryRepairStandardDataListCom(queryRepairStandardDataListComReqDto)/*vcase invoke 同服务,同domain*/;




//步骤1: M4执行标准数据【循环开始】 - implementStandardDataLoopStart
     //ModelCode: circulationCollections
        for (StandardDataDto circulationCollectionsRes: queryRepairStandardDataListComRespDto.getStandardDataList()){


//步骤2: D4执行修复已产生的标准数据(公共) - implementRepairTheGeneratedStandardDataCom
     ImplementRepairTheGeneratedStandardDataComRespDto implementRepairTheGeneratedStandardDataComRespDto = null;
    ImplementRepairTheGeneratedStandardDataComReqDto implementRepairTheGeneratedStandardDataComReqDto=new ImplementRepairTheGeneratedStandardDataComReqDto();
  if(circulationCollectionsRes!=null){
      implementRepairTheGeneratedStandardDataComReqDto.setDataResultId(circulationCollectionsRes.getDataResultId());//SimpleFieldAssign//sourceId:1865087_1
implementRepairTheGeneratedStandardDataComReqDto.setDataResult(circulationCollectionsRes.getDataResult());//SimpleFieldAssign//sourceId:1865104_1
implementRepairTheGeneratedStandardDataComReqDto.setDataType(circulationCollectionsRes.getDataType());//SimpleFieldAssign//sourceId:1865105_1
implementRepairTheGeneratedStandardDataComReqDto.setUpdateCycleId(circulationCollectionsRes.getUpdateCycleId());//SimpleFieldAssign//sourceId:1865123_1
implementRepairTheGeneratedStandardDataComReqDto.setCycleId(circulationCollectionsRes.getPeriodId());//SimpleFieldAssign//sourceId:1865084_1
implementRepairTheGeneratedStandardDataComReqDto.setEntityId(circulationCollectionsRes.getEntityId());//SimpleFieldAssign//sourceId:1865085_1
implementRepairTheGeneratedStandardDataComReqDto.setBelongToContentId(circulationCollectionsRes.getBelongToContentId());//SimpleFieldAssign//sourceId:1865098_1
implementRepairTheGeneratedStandardDataComReqDto.setParentSubMidCycleType(circulationCollectionsRes.getParentSubMidCycleType());//SimpleFieldAssign//sourceId:1865083_1
implementRepairTheGeneratedStandardDataComReqDto.setPersonLiableObjId(circulationCollectionsRes.getPersonLiableObjId());//SimpleFieldAssign//sourceId:1865090_1
implementRepairTheGeneratedStandardDataComReqDto.setBizRoleObjCode(circulationCollectionsRes.getBizRoleObjCode());//SimpleFieldAssign//sourceId:1865091_1
implementRepairTheGeneratedStandardDataComReqDto.setEventBatchUpdateCode(circulationCollectionsRes.getEventBatchUpdateCode());//SimpleFieldAssign//sourceId:1865088_1
implementRepairTheGeneratedStandardDataComReqDto.setCalcStartTime(circulationCollectionsRes.getCalcStartTime());//SimpleFieldAssign//sourceId:1865089_1
    }
if(reqDto!=null){
      implementRepairTheGeneratedStandardDataComReqDto.setEvaluationTemplateId(reqDto.getThemeContentId());//SimpleFieldAssign//sourceId:1865086_1
    }

    /*D4执行修复已产生的标准数据(公共)[9790]   */
    Assert.isNull(implementRepairTheGeneratedStandardDataComReqDto.getDataResultId(),"D4执行修复标准数据(公共)-D4执行修复已产生的标准数据(公共)-数据结果ID 不能为空",false);
Assert.isNull(implementRepairTheGeneratedStandardDataComReqDto.getDataResult(),"D4执行修复标准数据(公共)-D4执行修复已产生的标准数据(公共)-数据值结果不能为空",false);
Assert.isNull(implementRepairTheGeneratedStandardDataComReqDto.getDataType(),"D4执行修复标准数据(公共)-D4执行修复已产生的标准数据(公共)-数据点类型不能为空",false);
Assert.isNull(implementRepairTheGeneratedStandardDataComReqDto.getUpdateCycleId(),"D4执行修复标准数据(公共)-D4执行修复已产生的标准数据(公共)-更新周期ID不能为空",false);
Assert.isNull(implementRepairTheGeneratedStandardDataComReqDto.getCycleId(),"D4执行修复标准数据(公共)-D4执行修复已产生的标准数据(公共)-归属周期ID不能为空",false);
Assert.isNull(implementRepairTheGeneratedStandardDataComReqDto.getEntityId(),"D4执行修复标准数据(公共)-D4执行修复已产生的标准数据(公共)-归属内容表主键ID不能为空",false);
Assert.isNull(implementRepairTheGeneratedStandardDataComReqDto.getBelongToContentId(),"D4执行修复标准数据(公共)-D4执行修复已产生的标准数据(公共)-数据归属内容表主键ID不能为空",false);
Assert.isNull(implementRepairTheGeneratedStandardDataComReqDto.getParentSubMidCycleType(),"D4执行修复标准数据(公共)-D4执行修复已产生的标准数据(公共)-父子中过程周期类型不能为空",false);
Assert.isNull(implementRepairTheGeneratedStandardDataComReqDto.getEvaluationTemplateId(),"D4执行修复标准数据(公共)-D4执行修复已产生的标准数据(公共)-冗余评价模板ID不能为空",false);
Assert.isNull(implementRepairTheGeneratedStandardDataComReqDto.getPersonLiableObjId(),"D4执行修复标准数据(公共)-D4执行修复已产生的标准数据(公共)-填报评价责任人对象ID不能为空",false);
Assert.isNull(implementRepairTheGeneratedStandardDataComReqDto.getBizRoleObjCode(),"D4执行修复标准数据(公共)-D4执行修复已产生的标准数据(公共)-填报评价责任人业务角色标识不能为空",false);
      implementRepairTheGeneratedStandardDataComRespDto = implementRepairTheGeneratedStandardDataCom(implementRepairTheGeneratedStandardDataComReqDto)/*vcase invoke 同服务,同domain*/;




//步骤3: M4-执行【循环结束】 - implementLoopStopCalc
     //ModelCode: circulationEnd
        }


ImplementRepairStandardDataComRespDto retData = new ImplementRepairStandardDataComRespDto();





return retData;
  }
/**
   * D4查询修复标准数据列表(公共)[9797]
   * gen by moon at 6/17/2024, 12:33:34 AM
   */
  @Trace(operationName = "D4查询修复标准数据列表(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public QueryRepairStandardDataListComRespDto queryRepairStandardDataListCom(QueryRepairStandardDataListComReqDto reqDto){


      List<OmsStandardDataResult> listOmsStandardDataResult_1 =new ArrayList<>();
//步骤0: M4查询修复标准数据列表 - queryRepairStandardDataList
     List<OmsStandardDataResult> listOmsStandardDataResult =new ArrayList<>();
    QueryRepairStandardDataListReq queryRepairStandardDataListReq=new QueryRepairStandardDataListReq();
  if(reqDto!=null){
      queryRepairStandardDataListReq.setDataType(reqDto.getDataType());//SimpleFieldAssign//sourceId:1865399_1
queryRepairStandardDataListReq.setResultType(reqDto.getResultType());//SimpleFieldAssign//sourceId:1865400_1
      queryRepairStandardDataListReq.setThemeContentId(reqDto.getThemeContentId());//SimpleFieldAssign//sourceId:1865048_1
queryRepairStandardDataListReq.setExtendedField3(reqDto.getExtendedField3());//SimpleFieldAssign//sourceId:1874105_1
queryRepairStandardDataListReq.setExtendedField4(reqDto.getExtendedField4());//SimpleFieldAssign//sourceId:1874106_1
queryRepairStandardDataListReq.setIsArchive(reqDto.getIsArchive());//SimpleFieldAssign//sourceId:1873934_1
queryRepairStandardDataListReq.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1865049_1
    }

    /*M4查询修复标准数据列表[9796]   */
Assert.isNull(queryRepairStandardDataListReq.getSpaceId(),"D4查询修复标准数据列表(公共)-M4查询修复标准数据列表-创建于空间ID不能为空",false);
      listOmsStandardDataResult = mOmsStandardDataResultService.queryRepairStandardDataList(queryRepairStandardDataListReq)/*vcase invoke 本地 method 方法调用;*/;


      listOmsStandardDataResult_1 = listOmsStandardDataResult;

QueryRepairStandardDataListComRespDto retData = new QueryRepairStandardDataListComRespDto();
  retData.setStandardDataList(listOmsStandardDataResult_1.stream().map(item -> BeanUtil.toBean(item, StandardDataDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1865053_1




return retData;
  }
/**
   * D4分析修复标准数据填报责任人对象ID(公共)[9799]
   * gen by moon at 6/13/2024, 4:11:11 PM
   */
  @Trace(operationName = "D4分析修复标准数据填报责任人对象ID(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public AnalysisRepairStandardPersonLiableObjIdComRespDto analysisRepairStandardPersonLiableObjIdCom(AnalysisRepairStandardPersonLiableObjIdComReqDto reqDto){


      ImplementCalcReceivingField005RespDto receptionServiceRes_1 =null;
if((reqDto!= null&&  reqDto.getDataType() !=null && reqDto.getDataType().equals("SUBJECTIVE_MARK"))) {
        //if(D4分析修复标准数据填报责任人对象ID(公共).数据点类型 等于 主观评分)  69941

QueryVirtualOrgMemberDetailComRespDto queryVirtualOrgMemberDetailComRespDto = null;
    QueryVirtualOrgMemberDetailComReqDto queryVirtualOrgMemberDetailComReqDto=new QueryVirtualOrgMemberDetailComReqDto();
  queryVirtualOrgMemberDetailComReqDto.setIsArchive("FALSE");//sourceId:1865268_1_69943
if(reqDto!=null){
      queryVirtualOrgMemberDetailComReqDto.setVirtualOrgInductionRecordId(reqDto.getPersonLiableObjStanddardId());//SimpleFieldAssign//sourceId:1865265_1_69943
queryVirtualOrgMemberDetailComReqDto.setEntityId(reqDto.getBelongToContentId());//SimpleFieldAssign//sourceId:1865266_1_69943
queryVirtualOrgMemberDetailComReqDto.setRoleCode(reqDto.getBizRoleObjCode());//SimpleFieldAssign//sourceId:1865267_1_69943
    }

    /*D3-查询虚拟组织成员详情(公共)[5937]   */
    Assert.isNull(queryVirtualOrgMemberDetailComReqDto.getVirtualOrgInductionRecordId(),"D4分析修复标准数据填报责任人对象ID(公共)-D3-查询虚拟组织成员详情(公共)-虚拟组织成员就职记录ID不能为空",false);
Assert.isNull(queryVirtualOrgMemberDetailComReqDto.getEntityId(),"D4分析修复标准数据填报责任人对象ID(公共)-D3-查询虚拟组织成员详情(公共)-冗余内容表主键ID不能为空",false);
Assert.isNull(queryVirtualOrgMemberDetailComReqDto.getRoleCode(),"D4分析修复标准数据填报责任人对象ID(公共)-D3-查询虚拟组织成员详情(公共)-角色标识不能为空",false);
Assert.isNull(queryVirtualOrgMemberDetailComReqDto.getIsArchive(),"D4分析修复标准数据填报责任人对象ID(公共)-D3-查询虚拟组织成员详情(公共)-是否存档不能为空",false);
      queryVirtualOrgMemberDetailComRespDto = fwAppVirtualOrgClient.queryVirtualOrgMemberDetailCom(queryVirtualOrgMemberDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



//ModelCode: receptionService
        ImplementCalcReceivingField005RespDto receptionServiceRes = null;
    if(queryVirtualOrgMemberDetailComRespDto !=null){
          ImplementCalcReceivingField005ReqDto receptionServiceReq=new ImplementCalcReceivingField005ReqDto();
  if(queryVirtualOrgMemberDetailComRespDto!=null){
      receptionServiceReq.setPersonLiableObjId(queryVirtualOrgMemberDetailComRespDto.getVirtualOrgMemberId());//SimpleFieldAssign//sourceId:1865263_1_69944
    }

    /*M4接收填报评价责任人对象ID[9539]  用于特殊方法接收上游入参。 */
//    Assert.isNull(receptionServiceReq.getPersonLiableObjId(),"D4分析修复标准数据填报责任人对象ID(公共)-M4接收填报评价责任人对象ID-填报评价责任人对象ID不能为空",false);
      receptionServiceRes = nbSystemTestDomain.implementCalcReceivingField005(receptionServiceReq);


      receptionServiceRes_1 = receptionServiceRes;
           }
      }
else if((!(reqDto!= null&&  reqDto.getDataType() !=null && reqDto.getDataType().equals("SUBJECTIVE_MARK")))){
       //elseif(D4分析修复标准数据填报责任人对象ID(公共).数据点类型 不等于 主观评分)  69942

//ModelCode: receptionService
        ImplementCalcReceivingField005RespDto receptionServiceRes_2 = null;
    ImplementCalcReceivingField005ReqDto receptionServiceReq_1=new ImplementCalcReceivingField005ReqDto();
  if(reqDto!=null){
      receptionServiceReq_1.setPersonLiableObjId(reqDto.getPersonLiableObjId());//SimpleFieldAssign//sourceId:1865263_1_69945
    }

    /*M4接收填报评价责任人对象ID[9539]  用于特殊方法接收上游入参。 */
//    Assert.isNull(receptionServiceReq_1.getPersonLiableObjId(),"D4分析修复标准数据填报责任人对象ID(公共)-M4接收填报评价责任人对象ID-填报评价责任人对象ID不能为空",false);
      receptionServiceRes_2 = nbSystemTestDomain.implementCalcReceivingField005(receptionServiceReq_1);


      receptionServiceRes_1 = receptionServiceRes_2;
    }
AnalysisRepairStandardPersonLiableObjIdComRespDto retData = new AnalysisRepairStandardPersonLiableObjIdComRespDto();
  if(receptionServiceRes_1!=null){
      retData.setPersonLiableObjId(receptionServiceRes_1.getPersonLiableObjId());//SimpleFieldAssign//sourceId:1865272_1
    }




return retData;
  }
/**
   * D4执行修复周期阶段资料对应标准数据时间切片(运维接口)[9846]
   * gen by moon at 6/22/2024, 10:10:44 AM
   */
  @Trace(operationName = "D4执行修复周期阶段资料对应标准数据时间切片(运维接口)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementRepairCycleStageDataCorrespondingStandardDataTimeSliceComRespDto implementRepairCycleStageDataCorrespondingStandardDataTimeSliceCom(ImplementRepairCycleStageDataCorrespondingStandardDataTimeSliceComReqDto reqDto){


      //virtualUsage M4执行标准数据【循环开始】  70583
      //ModelCode: circulationCollections
        for (StandardDataDto circulationCollectionsRes: reqDto.getStandardDataList()){

//virtualUsage D3查目标归属周期详情(公共)  70585
      QueryTargetBeCycleDetailComRespDto queryTargetBeCycleDetailComRespDto = null;
    QueryTargetBeCycleDetailComReqDto queryTargetBeCycleDetailComReqDto=new QueryTargetBeCycleDetailComReqDto();
  if(circulationCollectionsRes!=null){
      queryTargetBeCycleDetailComReqDto.setCycleId(circulationCollectionsRes.getPeriodId());//SimpleFieldAssign//sourceId:1886747_1_70585
queryTargetBeCycleDetailComReqDto.setEntityId(circulationCollectionsRes.getEntityId());//SimpleFieldAssign//sourceId:1886749_1_70585
queryTargetBeCycleDetailComReqDto.setParentSubMidCycleType(circulationCollectionsRes.getParentSubMidCycleType());//SimpleFieldAssign//sourceId:1886748_1_70585
    }

    /*D3查目标归属周期详情(公共)[9544]   */
    Assert.isNull(queryTargetBeCycleDetailComReqDto.getCycleId(),"D4执行修复周期阶段资料对应标准数据时间切片(运维接口)-D3查目标归属周期详情(公共)-归属周期ID不能为空",false);
Assert.isNull(queryTargetBeCycleDetailComReqDto.getEntityId(),"D4执行修复周期阶段资料对应标准数据时间切片(运维接口)-D3查目标归属周期详情(公共)-归属内容表主键ID不能为空",false);
Assert.isNull(queryTargetBeCycleDetailComReqDto.getParentSubMidCycleType(),"D4执行修复周期阶段资料对应标准数据时间切片(运维接口)-D3查目标归属周期详情(公共)-父子中过程周期类型不能为空",false);
      queryTargetBeCycleDetailComRespDto = fwAppTargetCalcClient.queryTargetBeCycleDetailCom(queryTargetBeCycleDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



if((queryTargetBeCycleDetailComRespDto!= null&& queryTargetBeCycleDetailComRespDto.getTargetAttributionCycleId() != null )) {
        //if(D3查目标归属周期详情(公共).目标归属周期ID 值不等于空 )  70586

boolean bOOLEAN ;
    if(queryTargetBeCycleDetailComRespDto !=null){
          OmsStandardDataResult omsStandardDataResult=new OmsStandardDataResult();
  if(circulationCollectionsRes!=null){
      omsStandardDataResult.setDataResultId(circulationCollectionsRes.getDataResultId());//SimpleFieldAssign//sourceId:1886786_1_70588
    }
if(queryTargetBeCycleDetailComRespDto!=null){
      omsStandardDataResult.setWorkCycleUpdateSlice(queryTargetBeCycleDetailComRespDto.getWorkCycleUpdateSlice());//SimpleFieldAssign//sourceId:1886788_1_70588
    }

    /*4-01-01修改标准数据[2860]   */
    Assert.isNull(omsStandardDataResult.getDataResultId(),"D4执行修复周期阶段资料对应标准数据时间切片(运维接口)-4-01-01修改标准数据-数据结果ID 不能为空",false);
Assert.isNull(omsStandardDataResult.getWorkCycleUpdateSlice(),"D4执行修复周期阶段资料对应标准数据时间切片(运维接口)-4-01-01修改标准数据-工作周期更新切片不能为空",false);
      bOOLEAN = mOmsStandardDataResultService.updateStandardData(omsStandardDataResult)/*vcase invoke 本地 method 方法调用;*/;



           }
      }
else if((queryTargetBeCycleDetailComRespDto!= null&& queryTargetBeCycleDetailComRespDto.getTargetAttributionCycleId() == null )){
       //elseif(D3查目标归属周期详情(公共).目标归属周期ID 值等于空 )  70587

ImplementDebugBusinessDataRedisComRespDto implementDebugBusinessDataRedisComRespDto = null;
    ImplementDebugBusinessDataRedisComReqDto implementDebugBusinessDataRedisComReqDto=new ImplementDebugBusinessDataRedisComReqDto();
  implementDebugBusinessDataRedisComReqDto.setBusinessDataObject("BUSINESS_DATA_OBJECT_TEST");//sourceId:1886804_1_70589
implementDebugBusinessDataRedisComReqDto.setDebugScene("SINGLE_OBJECT");//CUSTOM_CONVENTION//sourceId:1886805_1_70589
implementDebugBusinessDataRedisComReqDto.setWrongObjectDescribe("对不起，该标准数据找不到目标归属周期ID");//CUSTOM_CONVENTION//sourceId:1886806_1_70589
if(circulationCollectionsRes!=null){
      implementDebugBusinessDataRedisComReqDto.setCustomField11(circulationCollectionsRes.getDataResultId());//SimpleFieldAssign//sourceId:1886810_1_70589
    }

    /*D2执行DEBUG业务对象数据Redis(公共)[9660]   */
    Assert.isNull(implementDebugBusinessDataRedisComReqDto.getBusinessDataObject(),"D4执行修复周期阶段资料对应标准数据时间切片(运维接口)-D2执行DEBUG业务对象数据Redis(公共)-业务数据对象不能为空",false);
Assert.isNull(implementDebugBusinessDataRedisComReqDto.getDebugScene(),"D4执行修复周期阶段资料对应标准数据时间切片(运维接口)-D2执行DEBUG业务对象数据Redis(公共)-DEBUG业务场景不能为空",false);
Assert.isNull(implementDebugBusinessDataRedisComReqDto.getWrongObjectDescribe(),"D4执行修复周期阶段资料对应标准数据时间切片(运维接口)-D2执行DEBUG业务对象数据Redis(公共)-错误对象描述不能为空",false);
Assert.isNull(implementDebugBusinessDataRedisComReqDto.getCustomField11(),"D4执行修复周期阶段资料对应标准数据时间切片(运维接口)-D2执行DEBUG业务对象数据Redis(公共)-数据结果ID不能为空",false);
      implementDebugBusinessDataRedisComRespDto = fwCompBusinessAtomClient.implementDebugBusinessDataRedisCom(implementDebugBusinessDataRedisComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



    }
//virtualUsage M4-执行【循环结束】  70584
      //ModelCode: circulationEnd
        }

ImplementRepairCycleStageDataCorrespondingStandardDataTimeSliceComRespDto retData = new ImplementRepairCycleStageDataCorrespondingStandardDataTimeSliceComRespDto();





return retData;
  }
/**
   * D4执行检测进度型指标标准数据合规性（运维接口）[9861]
   * gen by moon at 6/23/2024, 9:04:47 PM
   */
  @Trace(operationName = "D4执行检测进度型指标标准数据合规性（运维接口）")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementInspectProgressObjectiveDataComplianceComRespDto implementInspectProgressObjectiveDataComplianceCom(ImplementInspectProgressObjectiveDataComplianceComReqDto reqDto){


      //virtualUsage D4-1查询标准数据列表(公共)  70741
      QueryStandardDataListComRespDto queryStandardDataListComRespDto = null;
    QueryStandardDataListComReqDto queryStandardDataListComReqDto=new QueryStandardDataListComReqDto();
  queryStandardDataListComReqDto.setResultType("MANUAL_INPUT");//sourceId:1890750_1_70741
queryStandardDataListComReqDto.setDataUsageSceneCode("TARGET_PLAN_CALC_DATA_STATISTICS");//sourceId:1890902_1_70741
queryStandardDataListComReqDto.setIsArchive("FALSE");//sourceId:1890752_1_70741
queryStandardDataListComReqDto.setDataType("PROGRESS_VALUE");//sourceId:1890754_1_70741
if(reqDto!=null){
      queryStandardDataListComReqDto.setThemeContentId(reqDto.getThemeContentId());//SimpleFieldAssign//sourceId:1890751_1_70741
queryStandardDataListComReqDto.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1890753_1_70741
    }

    /*D4-1查询标准数据列表(公共)[4696]   */
    Assert.isNull(queryStandardDataListComReqDto.getResultType(),"D4执行检测进度型指标标准数据合规性（运维接口）-D4-1查询标准数据列表(公共)-结果产生类型不能为空",false);
Assert.isNull(queryStandardDataListComReqDto.getDataUsageSceneCode(),"D4执行检测进度型指标标准数据合规性（运维接口）-D4-1查询标准数据列表(公共)-数据业务场景不能为空",false);
Assert.isNull(queryStandardDataListComReqDto.getIsArchive(),"D4执行检测进度型指标标准数据合规性（运维接口）-D4-1查询标准数据列表(公共)-是否存档不能为空",false);
Assert.isNull(queryStandardDataListComReqDto.getDataType(),"D4执行检测进度型指标标准数据合规性（运维接口）-D4-1查询标准数据列表(公共)-数据点类型不能为空",false);
      queryStandardDataListComRespDto = standardDataService.queryStandardDataListCom(queryStandardDataListComReqDto)/*vcase invoke isSameApp*/;



if((queryStandardDataListComRespDto!= null&&  queryStandardDataListComRespDto.getStandardDataList() !=null && queryStandardDataListComRespDto.getStandardDataList().size()>0)) {
        //if(D4-1查询标准数据列表(公共).标准数据列表数据集条数 大于 0)  70742

//ModelCode: circulationCollections
        for (com.wicket.okrcalc.base.service.dto.common.StandardDataDto circulationCollectionsRes: queryStandardDataListComRespDto.getStandardDataList()){

if((circulationCollectionsRes!= null&&  circulationCollectionsRes.getBelongToContentTypeCode() !=null && circulationCollectionsRes.getBelongToContentTypeCode().equals("OMS_TARGET_OBJECTIVE"))) {
        //if(M4执行标准数据【循环开始】.数据归属内容表类型编码 等于 指标表)  70745

QueryTargetObjDetailComRespDto queryTargetObjDetailComRespDto = null;
    QueryTargetObjDetailComReqDto queryTargetObjDetailComReqDto=new QueryTargetObjDetailComReqDto();
  if(circulationCollectionsRes!=null){
      queryTargetObjDetailComReqDto.setObjectiveId(circulationCollectionsRes.getBelongToContentId());//SimpleFieldAssign//sourceId:1890779_1_70746
    }

    /*D3-3查询指标详情(公共)[2794]   */
    Assert.isNull(queryTargetObjDetailComReqDto.getObjectiveId(),"D4执行检测进度型指标标准数据合规性（运维接口）-D3-3查询指标详情(公共)-指标ID不能为空",false);
      queryTargetObjDetailComRespDto = fwAppIndexSystemClient.queryTargetObjDetailCom(queryTargetObjDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



if((queryTargetObjDetailComRespDto!= null&&  queryTargetObjDetailComRespDto.getTargetValueType() !=null && queryTargetObjDetailComRespDto.getTargetValueType().equals("PROGRESS"))) {
        //if(D3-3查询指标详情(公共).冗余指标业务类型 等于 进度型)  70747

OmsStandardDataResult omsStandardDataResult = null;
    QueryStandardDataDetailReq queryStandardDataDetailReq=new QueryStandardDataDetailReq();
  queryStandardDataDetailReq.setDataType("ACTUAL_VALUE");//sourceId:1890895_1_70748
queryStandardDataDetailReq.setDataUsageSceneCode("TARGET_PLAN_CALC_DATA_STATISTICS");//sourceId:1890896_1_70748
queryStandardDataDetailReq.setResultType("MANUAL_INPUT");//sourceId:1890897_1_70748
queryStandardDataDetailReq.setIsArchive("FALSE");//sourceId:1890908_1_70748
if(circulationCollectionsRes!=null){
      queryStandardDataDetailReq.setUpdateCycleId(circulationCollectionsRes.getUpdateCycleId());//SimpleFieldAssign//sourceId:1890899_1_70748
queryStandardDataDetailReq.setPeriodId(circulationCollectionsRes.getPeriodId());//SimpleFieldAssign//sourceId:1890898_1_70748
queryStandardDataDetailReq.setParentSubMidCycleType(circulationCollectionsRes.getParentSubMidCycleType());//SimpleFieldAssign//sourceId:1890900_1_70748
queryStandardDataDetailReq.setEntityId(circulationCollectionsRes.getEntityId());//SimpleFieldAssign//sourceId:1890901_1_70748
    }

    /*4-01-01查实际值标准数据详情[2696]   */
    Assert.isNull(queryStandardDataDetailReq.getDataType(),"D4执行检测进度型指标标准数据合规性（运维接口）-4-01-01查实际值标准数据详情-数据点类型不能为空",false);
Assert.isNull(queryStandardDataDetailReq.getDataUsageSceneCode(),"D4执行检测进度型指标标准数据合规性（运维接口）-4-01-01查实际值标准数据详情-数据业务场景不能为空",false);
Assert.isNull(queryStandardDataDetailReq.getResultType(),"D4执行检测进度型指标标准数据合规性（运维接口）-4-01-01查实际值标准数据详情-结果产生类型不能为空",false);
Assert.isNull(queryStandardDataDetailReq.getUpdateCycleId(),"D4执行检测进度型指标标准数据合规性（运维接口）-4-01-01查实际值标准数据详情-更新周期ID不能为空",false);
Assert.isNull(queryStandardDataDetailReq.getPeriodId(),"D4执行检测进度型指标标准数据合规性（运维接口）-4-01-01查实际值标准数据详情-周期ID不能为空",false);
Assert.isNull(queryStandardDataDetailReq.getParentSubMidCycleType(),"D4执行检测进度型指标标准数据合规性（运维接口）-4-01-01查实际值标准数据详情-父子中周期类型不能为空",false);
Assert.isNull(queryStandardDataDetailReq.getEntityId(),"D4执行检测进度型指标标准数据合规性（运维接口）-4-01-01查实际值标准数据详情-归属内容表主键ID不能为空",false);
Assert.isNull(queryStandardDataDetailReq.getIsArchive(),"D4执行检测进度型指标标准数据合规性（运维接口）-4-01-01查实际值标准数据详情-是否存档不能为空",false);
      omsStandardDataResult = mOmsStandardDataResultService.queryStandardDataDetail(queryStandardDataDetailReq)/*vcase invoke 本地 method 方法调用;*/;



if((omsStandardDataResult != null )) {
        //if(4-01-01查实际值标准数据详情.出参 值不等于空 )  70749

boolean bOOLEAN ;
    if(omsStandardDataResult !=null){
          OmsStandardDataResult omsStandardDataResult_2=new OmsStandardDataResult();
  if(omsStandardDataResult!=null){
      omsStandardDataResult_2.setDataResultId(omsStandardDataResult.getDataResultId());//SimpleFieldAssign//sourceId:1890943_1_70750
    }
if(circulationCollectionsRes!=null){
      omsStandardDataResult_2.setDataResult(circulationCollectionsRes.getDataResult());//SimpleFieldAssign//sourceId:1890944_1_70750
    }

    /*4-01-01修改标准数据[2860]   */
    Assert.isNull(omsStandardDataResult_2.getDataResultId(),"D4执行检测进度型指标标准数据合规性（运维接口）-4-01-01修改标准数据-数据结果ID 不能为空",false);
Assert.isNull(omsStandardDataResult_2.getDataResult(),"D4执行检测进度型指标标准数据合规性（运维接口）-4-01-01修改标准数据-数据值结果不能为空",false);
      bOOLEAN = mOmsStandardDataResultService.updateStandardData(omsStandardDataResult_2)/*vcase invoke 本地 method 方法调用;*/;



           }
      }
else if((omsStandardDataResult == null )){
       //elseif(4-01-01查实际值标准数据详情.出参 值等于空 )  70751

OmsStandardDataResult omsStandardDataResult_3 = null;
    QueryStandardDataDetailReq queryStandardDataDetailReq_1=new QueryStandardDataDetailReq();
  if(circulationCollectionsRes!=null){
      queryStandardDataDetailReq_1.setDataResultId(circulationCollectionsRes.getDataResultId());//SimpleFieldAssign//sourceId:1891084_1_70752
    }

    /*4-01-01查进度值标准数据详情[2696]   */
    Assert.isNull(queryStandardDataDetailReq_1.getDataResultId(),"D4执行检测进度型指标标准数据合规性（运维接口）-4-01-01查进度值标准数据详情-数据结果ID 不能为空",false);
      omsStandardDataResult_3 = mOmsStandardDataResultService.queryStandardDataDetail(queryStandardDataDetailReq_1)/*vcase invoke 本地 method 方法调用;*/;



String string = null;
    if(omsStandardDataResult_3 !=null){
          OmsStandardDataResult omsStandardDataResult_5=new OmsStandardDataResult();
  omsStandardDataResult_5.setDataType("ACTUAL_VALUE");//sourceId:1891047_1_70753
if(omsStandardDataResult_3!=null){
      omsStandardDataResult_5.setDataResult(omsStandardDataResult_3.getDataResult());//SimpleFieldAssign//sourceId:1891039_1_70753
omsStandardDataResult_5.setUnit(omsStandardDataResult_3.getUnit());//SimpleFieldAssign//sourceId:1891043_1_70753
omsStandardDataResult_5.setResultType(omsStandardDataResult_3.getResultType());//SimpleFieldAssign//sourceId:1891040_1_70753
omsStandardDataResult_5.setParentSubMidCycleType(omsStandardDataResult_3.getParentSubMidCycleType());//SimpleFieldAssign//sourceId:1891064_1_70753
omsStandardDataResult_5.setPeriodId(omsStandardDataResult_3.getPeriodId());//SimpleFieldAssign//sourceId:1891044_1_70753
omsStandardDataResult_5.setCycleStartTime(omsStandardDataResult_3.getCycleStartTime());//SimpleFieldAssign//sourceId:1891058_1_70753
omsStandardDataResult_5.setCycleEndTime(omsStandardDataResult_3.getCycleEndTime());//SimpleFieldAssign//sourceId:1891059_1_70753
omsStandardDataResult_5.setCycleTypeCode(omsStandardDataResult_3.getCycleTypeCode());//SimpleFieldAssign//sourceId:1891046_1_70753
omsStandardDataResult_5.setCycleTypeInstanceCode(omsStandardDataResult_3.getCycleTypeInstanceCode());//SimpleFieldAssign//sourceId:1891045_1_70753
omsStandardDataResult_5.setUpdateCycleId(omsStandardDataResult_3.getUpdateCycleId());//SimpleFieldAssign//sourceId:1891065_1_70753
omsStandardDataResult_5.setUpdateCycleStartTime(omsStandardDataResult_3.getUpdateCycleStartTime());//SimpleFieldAssign//sourceId:1891074_1_70753
omsStandardDataResult_5.setUpdateCycleEndTime(omsStandardDataResult_3.getUpdateCycleEndTime());//SimpleFieldAssign//sourceId:1891075_1_70753
omsStandardDataResult_5.setUpdateCycleTypeCode(omsStandardDataResult_3.getUpdateCycleTypeCode());//SimpleFieldAssign//sourceId:1891070_1_70753
omsStandardDataResult_5.setWorkCycleUpdateSlice(omsStandardDataResult_3.getWorkCycleUpdateSlice());//SimpleFieldAssign//sourceId:1891069_1_70753
omsStandardDataResult_5.setStandardDataCalcCycleModel(omsStandardDataResult_3.getStandardDataCalcCycleModel());//SimpleFieldAssign//sourceId:1891071_1_70753
omsStandardDataResult_5.setDataUsageSceneCode(omsStandardDataResult_3.getDataUsageSceneCode());//SimpleFieldAssign//sourceId:1891073_1_70753
omsStandardDataResult_5.setIsWorkCycleData(omsStandardDataResult_3.getIsWorkCycleData());//SimpleFieldAssign//sourceId:1891076_1_70753
omsStandardDataResult_5.setTableTypeCode(omsStandardDataResult_3.getTableTypeCode());//SimpleFieldAssign//sourceId:1891048_1_70753
omsStandardDataResult_5.setEntityId(omsStandardDataResult_3.getEntityId());//SimpleFieldAssign//sourceId:1891049_1_70753
omsStandardDataResult_5.setFromContentTableTypeCode(omsStandardDataResult_3.getFromContentTableTypeCode());//SimpleFieldAssign//sourceId:1891050_1_70753
omsStandardDataResult_5.setFromContentEntityId(omsStandardDataResult_3.getFromContentEntityId());//SimpleFieldAssign//sourceId:1891051_1_70753
omsStandardDataResult_5.setPersonLiableObjId(omsStandardDataResult_3.getPersonLiableObjId());//SimpleFieldAssign//sourceId:1891052_1_70753
omsStandardDataResult_5.setPersonLiableTypeCode(omsStandardDataResult_3.getPersonLiableTypeCode());//SimpleFieldAssign//sourceId:1891055_1_70753
omsStandardDataResult_5.setBizRoleObjId(omsStandardDataResult_3.getBizRoleObjId());//SimpleFieldAssign//sourceId:1891053_1_70753
omsStandardDataResult_5.setBizRoleObjCode(omsStandardDataResult_3.getBizRoleObjCode());//SimpleFieldAssign//sourceId:1891057_1_70753
omsStandardDataResult_5.setBizRoleObjName(omsStandardDataResult_3.getBizRoleObjName());//SimpleFieldAssign//sourceId:1891054_1_70753
omsStandardDataResult_5.setSubjectLifeCycle(omsStandardDataResult_3.getSubjectLifeCycle());//SimpleFieldAssign//sourceId:1891056_1_70753
omsStandardDataResult_5.setBelongToPersonalIdentityId(omsStandardDataResult_3.getBelongToPersonalIdentityId());//SimpleFieldAssign//sourceId:1891078_1_70753
omsStandardDataResult_5.setBelongToPersonalIdentityTypeCode(omsStandardDataResult_3.getBelongToPersonalIdentityTypeCode());//SimpleFieldAssign//sourceId:1891077_1_70753
omsStandardDataResult_5.setBelongToPersonalIdentityRoleCode(omsStandardDataResult_3.getBelongToPersonalIdentityRoleCode());//SimpleFieldAssign//sourceId:1891092_1_70753
omsStandardDataResult_5.setBelongToContentTypeCode(omsStandardDataResult_3.getBelongToContentTypeCode());//SimpleFieldAssign//sourceId:1891060_1_70753
omsStandardDataResult_5.setBelongToContentId(omsStandardDataResult_3.getBelongToContentId());//SimpleFieldAssign//sourceId:1891061_1_70753
omsStandardDataResult_5.setExtendedField1(omsStandardDataResult_3.getExtendedField1());//SimpleFieldAssign//sourceId:1891066_1_70753
omsStandardDataResult_5.setExtendedField2(omsStandardDataResult_3.getExtendedField2());//SimpleFieldAssign//sourceId:1891067_1_70753
omsStandardDataResult_5.setExtendedField3(omsStandardDataResult_3.getExtendedField3());//SimpleFieldAssign//sourceId:1891079_1_70753
omsStandardDataResult_5.setExtendedField4(omsStandardDataResult_3.getExtendedField4());//SimpleFieldAssign//sourceId:1891090_1_70753
omsStandardDataResult_5.setExtendedField5(omsStandardDataResult_3.getExtendedField5());//SimpleFieldAssign//sourceId:1891091_1_70753
omsStandardDataResult_5.setThemeContentTypeCode(omsStandardDataResult_3.getThemeContentTypeCode());//SimpleFieldAssign//sourceId:1891062_1_70753
omsStandardDataResult_5.setThemeContentId(omsStandardDataResult_3.getThemeContentId());//SimpleFieldAssign//sourceId:1891063_1_70753
omsStandardDataResult_5.setCalcStartTime(omsStandardDataResult_3.getCalcStartTime());//SimpleFieldAssign//sourceId:1891072_1_70753
omsStandardDataResult_5.setEventBatchUpdateCode(omsStandardDataResult_3.getEventBatchUpdateCode());//SimpleFieldAssign//sourceId:1891089_1_70753
    }

    /*4-01-01新增标准数据[2856]   */
    Assert.isNull(omsStandardDataResult_5.getDataResult(),"D4执行检测进度型指标标准数据合规性（运维接口）-4-01-01新增标准数据-数据值结果不能为空",false);
Assert.isNull(omsStandardDataResult_5.getUnit(),"D4执行检测进度型指标标准数据合规性（运维接口）-4-01-01新增标准数据-冗余单位不能为空",false);
Assert.isNull(omsStandardDataResult_5.getResultType(),"D4执行检测进度型指标标准数据合规性（运维接口）-4-01-01新增标准数据-结果产生类型不能为空",false);
Assert.isNull(omsStandardDataResult_5.getParentSubMidCycleType(),"D4执行检测进度型指标标准数据合规性（运维接口）-4-01-01新增标准数据-父子中周期类型不能为空",false);
Assert.isNull(omsStandardDataResult_5.getPeriodId(),"D4执行检测进度型指标标准数据合规性（运维接口）-4-01-01新增标准数据-周期ID不能为空",false);
Assert.isNull(omsStandardDataResult_5.getCycleStartTime(),"D4执行检测进度型指标标准数据合规性（运维接口）-4-01-01新增标准数据-周期开始时间不能为空",false);
Assert.isNull(omsStandardDataResult_5.getCycleEndTime(),"D4执行检测进度型指标标准数据合规性（运维接口）-4-01-01新增标准数据-周期结束时间不能为空",false);
Assert.isNull(omsStandardDataResult_5.getCycleTypeCode(),"D4执行检测进度型指标标准数据合规性（运维接口）-4-01-01新增标准数据-周期类型标识不能为空",false);
//Assert.isNull(omsStandardDataResult_5.getCycleTypeInstanceCode(),"D4执行检测进度型指标标准数据合规性（运维接口）-4-01-01新增标准数据-周期类型实例标识不能为空",false);
Assert.isNull(omsStandardDataResult_5.getUpdateCycleId(),"D4执行检测进度型指标标准数据合规性（运维接口）-4-01-01新增标准数据-更新周期ID不能为空",false);
Assert.isNull(omsStandardDataResult_5.getUpdateCycleStartTime(),"D4执行检测进度型指标标准数据合规性（运维接口）-4-01-01新增标准数据-更新周期开始时间不能为空",false);
Assert.isNull(omsStandardDataResult_5.getUpdateCycleEndTime(),"D4执行检测进度型指标标准数据合规性（运维接口）-4-01-01新增标准数据-更新周期结束时间不能为空",false);
Assert.isNull(omsStandardDataResult_5.getUpdateCycleTypeCode(),"D4执行检测进度型指标标准数据合规性（运维接口）-4-01-01新增标准数据-更新周期类型标识不能为空",false);
Assert.isNull(omsStandardDataResult_5.getWorkCycleUpdateSlice(),"D4执行检测进度型指标标准数据合规性（运维接口）-4-01-01新增标准数据-工作周期更新切片不能为空",false);
Assert.isNull(omsStandardDataResult_5.getStandardDataCalcCycleModel(),"D4执行检测进度型指标标准数据合规性（运维接口）-4-01-01新增标准数据-计算周期五模型不能为空",false);
Assert.isNull(omsStandardDataResult_5.getDataUsageSceneCode(),"D4执行检测进度型指标标准数据合规性（运维接口）-4-01-01新增标准数据-数据业务场景不能为空",false);
Assert.isNull(omsStandardDataResult_5.getIsWorkCycleData(),"D4执行检测进度型指标标准数据合规性（运维接口）-4-01-01新增标准数据-是否工作周期数据不能为空",false);
Assert.isNull(omsStandardDataResult_5.getDataType(),"D4执行检测进度型指标标准数据合规性（运维接口）-4-01-01新增标准数据-数据点类型不能为空",false);
Assert.isNull(omsStandardDataResult_5.getTableTypeCode(),"D4执行检测进度型指标标准数据合规性（运维接口）-4-01-01新增标准数据-归属内容表类型编码不能为空",false);
Assert.isNull(omsStandardDataResult_5.getEntityId(),"D4执行检测进度型指标标准数据合规性（运维接口）-4-01-01新增标准数据-归属内容表主键ID不能为空",false);
//Assert.isNull(omsStandardDataResult_5.getFromContentTableTypeCode(),"D4执行检测进度型指标标准数据合规性（运维接口）-4-01-01新增标准数据-来自内容表类型编码不能为空",false);
//Assert.isNull(omsStandardDataResult_5.getFromContentEntityId(),"D4执行检测进度型指标标准数据合规性（运维接口）-4-01-01新增标准数据-来自内容表主键ID不能为空",false);
Assert.isNull(omsStandardDataResult_5.getPersonLiableObjId(),"D4执行检测进度型指标标准数据合规性（运维接口）-4-01-01新增标准数据-填报评价责任人对象ID不能为空",false);
Assert.isNull(omsStandardDataResult_5.getPersonLiableTypeCode(),"D4执行检测进度型指标标准数据合规性（运维接口）-4-01-01新增标准数据-填报评价责任人身份类型编码不能为空",false);
Assert.isNull(omsStandardDataResult_5.getBizRoleObjId(),"D4执行检测进度型指标标准数据合规性（运维接口）-4-01-01新增标准数据-填报评价责任人业务角色对象ID不能为空",false);
Assert.isNull(omsStandardDataResult_5.getBizRoleObjCode(),"D4执行检测进度型指标标准数据合规性（运维接口）-4-01-01新增标准数据-填报评价责任人业务角色标识不能为空",false);
Assert.isNull(omsStandardDataResult_5.getBizRoleObjName(),"D4执行检测进度型指标标准数据合规性（运维接口）-4-01-01新增标准数据-填报评价责任人业务角色对象名称不能为空",false);
Assert.isNull(omsStandardDataResult_5.getSubjectLifeCycle(),"D4执行检测进度型指标标准数据合规性（运维接口）-4-01-01新增标准数据-主体生命周期不能为空",false);
Assert.isNull(omsStandardDataResult_5.getBelongToPersonalIdentityId(),"D4执行检测进度型指标标准数据合规性（运维接口）-4-01-01新增标准数据-数据归属对象ID不能为空",false);
Assert.isNull(omsStandardDataResult_5.getBelongToPersonalIdentityTypeCode(),"D4执行检测进度型指标标准数据合规性（运维接口）-4-01-01新增标准数据-数据归属对象类型编码不能为空",false);
Assert.isNull(omsStandardDataResult_5.getBelongToContentTypeCode(),"D4执行检测进度型指标标准数据合规性（运维接口）-4-01-01新增标准数据-数据归属内容表类型编码不能为空",false);
Assert.isNull(omsStandardDataResult_5.getBelongToContentId(),"D4执行检测进度型指标标准数据合规性（运维接口）-4-01-01新增标准数据-数据归属内容表主键ID不能为空",false);
Assert.isNull(omsStandardDataResult_5.getThemeContentTypeCode(),"D4执行检测进度型指标标准数据合规性（运维接口）-4-01-01新增标准数据-主题内容类型编码不能为空",false);
Assert.isNull(omsStandardDataResult_5.getThemeContentId(),"D4执行检测进度型指标标准数据合规性（运维接口）-4-01-01新增标准数据-主题内容ID不能为空",false);
Assert.isNull(omsStandardDataResult_5.getCalcStartTime(),"D4执行检测进度型指标标准数据合规性（运维接口）-4-01-01新增标准数据-计算开始时间不能为空",false);
Assert.isNull(omsStandardDataResult_5.getEventBatchUpdateCode(),"D4执行检测进度型指标标准数据合规性（运维接口）-4-01-01新增标准数据-事务内数据更新批次标识不能为空",false);
      string = mOmsStandardDataResultService.addStandardData(omsStandardDataResult_5)/*vcase invoke 本地 method 方法调用;*/;



           }
    }
      }
      }
//ModelCode: circulationEnd
        }

      }
ImplementInspectProgressObjectiveDataComplianceComRespDto retData = new ImplementInspectProgressObjectiveDataComplianceComRespDto();





return retData;
  }
/**
   * D4执行刷人工填报数据（运维-临时）[10238]
   * gen by moon at 9/22/2024, 10:35:47 PM
   */
  @Trace(operationName = "D4执行刷人工填报数据（运维-临时）")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementBrushManualFullDataRespDto implementBrushManualFullData(ImplementBrushManualFullDataReqDto reqDto){


      //virtualUsage M4-接收字段入参（计算使用）  72971
      //ModelCode: receptionService
        AddAcceptFieldRespDto receptionServiceRes = null;
    AddAcceptFieldReqDto receptionServiceReq=new AddAcceptFieldReqDto();
  receptionServiceReq.setDataResult(Double.valueOf("0"));//CUSTOM_CONVENTION//sourceId:2009406_1_72971
if(reqDto!=null){
      receptionServiceReq.setCycleId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:2009138_1_72971
receptionServiceReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:2009189_1_72971
    }

    /*M4-接收字段入参（计算使用）[6392]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq.getCycleId(),"D4执行刷人工填报数据（运维-临时）-M4-接收字段入参（计算使用）-周期ID不能为空",false);
Assert.isNull(receptionServiceReq.getEvaluationTemplateId(),"D4执行刷人工填报数据（运维-临时）-M4-接收字段入参（计算使用）-冗余评价模板ID不能为空",false);
Assert.isNull(receptionServiceReq.getDataResult(),"D4执行刷人工填报数据（运维-临时）-M4-接收字段入参（计算使用）-数据值结果不能为空",false);
      receptionServiceRes = nbSystemTestDomain.addAcceptField(receptionServiceReq);



//virtualUsage D3查询目标归属周期列表(公共)  72960
      QueryCurAndAncestorTargetAttributionCycleListComRespDto queryCurAndAncestorTargetAttributionCycleListComRespDto = null;
    QueryCurAndAncestorTargetAttributionCycleListComReqDto queryCurAndAncestorTargetAttributionCycleListComReqDto=new QueryCurAndAncestorTargetAttributionCycleListComReqDto();
  queryCurAndAncestorTargetAttributionCycleListComReqDto.setEvaObjEntityId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:2009183_1_72960
queryCurAndAncestorTargetAttributionCycleListComReqDto.setEvaObjTypeCode("EVA_OBJECT");//sourceId:2009184_1_72960
queryCurAndAncestorTargetAttributionCycleListComReqDto.setBelongToContentTypeCode("OMS_TARGET_OBJECTIVE");//sourceId:2009186_1_72960
queryCurAndAncestorTargetAttributionCycleListComReqDto.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:2009188_1_72960
if(reqDto!=null){
      queryCurAndAncestorTargetAttributionCycleListComReqDto.setCycleId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:2009185_1_72960
queryCurAndAncestorTargetAttributionCycleListComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:2009187_1_72960
    }

    /*D3查询目标归属周期列表(公共)[9728]   */
    Assert.isNull(queryCurAndAncestorTargetAttributionCycleListComReqDto.getCycleId(),"D4执行刷人工填报数据（运维-临时）-D3查询目标归属周期列表(公共)-归属周期ID不能为空",false);
Assert.isNull(queryCurAndAncestorTargetAttributionCycleListComReqDto.getEvaObjEntityId(),"D4执行刷人工填报数据（运维-临时）-D3查询目标归属周期列表(公共)-主树被评对象内容表主键ID不能为空",false);
Assert.isNull(queryCurAndAncestorTargetAttributionCycleListComReqDto.getEvaObjTypeCode(),"D4执行刷人工填报数据（运维-临时）-D3查询目标归属周期列表(公共)-主树被评对象类型编码不能为空",false);
Assert.isNull(queryCurAndAncestorTargetAttributionCycleListComReqDto.getBelongToContentTypeCode(),"D4执行刷人工填报数据（运维-临时）-D3查询目标归属周期列表(公共)-数据归属内容表类型编码不能为空",false);
Assert.isNull(queryCurAndAncestorTargetAttributionCycleListComReqDto.getEvaluationTemplateId(),"D4执行刷人工填报数据（运维-临时）-D3查询目标归属周期列表(公共)-冗余评价模板ID不能为空",false);
Assert.isNull(queryCurAndAncestorTargetAttributionCycleListComReqDto.getSpaceId(),"D4执行刷人工填报数据（运维-临时）-D3查询目标归属周期列表(公共)-创建于空间ID不能为空",false);
      queryCurAndAncestorTargetAttributionCycleListComRespDto = fwAppTargetCalcClient.queryCurAndAncestorTargetAttributionCycleListCom(queryCurAndAncestorTargetAttributionCycleListComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



if((queryCurAndAncestorTargetAttributionCycleListComRespDto!= null&&  queryCurAndAncestorTargetAttributionCycleListComRespDto.getTargetBelongCycleList() !=null && queryCurAndAncestorTargetAttributionCycleListComRespDto.getTargetBelongCycleList().size()>0)) {
        //if(D3查询目标归属周期列表(公共).目标归属周期列表数据集条数 大于 0)  72961

//ModelCode: circulationCollections
        for (TargetBelongCycleDto circulationCollectionsRes: queryCurAndAncestorTargetAttributionCycleListComRespDto.getTargetBelongCycleList()){

QueryStandardDataDetailComRespDto queryStandardDataDetailComRespDto = null;
    QueryStandardDataDetailComReqDto queryStandardDataDetailComReqDto=new QueryStandardDataDetailComReqDto();
  queryStandardDataDetailComReqDto.setDataType("ACTUAL_VALUE");//sourceId:2009387_1_72964
queryStandardDataDetailComReqDto.setResultType("MANUAL_INPUT");//sourceId:2009388_1_72964
queryStandardDataDetailComReqDto.setDataUsageSceneCode("TARGET_PLAN_CALC_DATA_STATISTICS");//sourceId:2009389_1_72964
queryStandardDataDetailComReqDto.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:2009393_1_72964
if(reqDto!=null){
      queryStandardDataDetailComReqDto.setPeriodId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:2009390_1_72964
queryStandardDataDetailComReqDto.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:2009392_1_72964
    }
if(circulationCollectionsRes!=null){
      queryStandardDataDetailComReqDto.setEntityId(circulationCollectionsRes.getEntityId());//SimpleFieldAssign//sourceId:2009391_1_72964
    }

    /*D4-1查实际值标准数据详情(公共)[2695]   */
    Assert.isNull(queryStandardDataDetailComReqDto.getPeriodId(),"D4执行刷人工填报数据（运维-临时）-D4-1查实际值标准数据详情(公共)-周期ID不能为空",false);
Assert.isNull(queryStandardDataDetailComReqDto.getDataType(),"D4执行刷人工填报数据（运维-临时）-D4-1查实际值标准数据详情(公共)-数据点类型不能为空",false);
Assert.isNull(queryStandardDataDetailComReqDto.getResultType(),"D4执行刷人工填报数据（运维-临时）-D4-1查实际值标准数据详情(公共)-结果产生类型不能为空",false);
Assert.isNull(queryStandardDataDetailComReqDto.getDataUsageSceneCode(),"D4执行刷人工填报数据（运维-临时）-D4-1查实际值标准数据详情(公共)-数据业务场景不能为空",false);
Assert.isNull(queryStandardDataDetailComReqDto.getEntityId(),"D4执行刷人工填报数据（运维-临时）-D4-1查实际值标准数据详情(公共)-归属内容表主键ID不能为空",false);
Assert.isNull(queryStandardDataDetailComReqDto.getThemeContentId(),"D4执行刷人工填报数据（运维-临时）-D4-1查实际值标准数据详情(公共)-主题内容ID不能为空",false);
Assert.isNull(queryStandardDataDetailComReqDto.getSubjectLifeCycle(),"D4执行刷人工填报数据（运维-临时）-D4-1查实际值标准数据详情(公共)-主体生命周期不能为空",false);
      queryStandardDataDetailComRespDto = standardDataService.queryStandardDataDetailCom(queryStandardDataDetailComReqDto)/*vcase invoke isSameApp*/;



QueryStandardDataDetailComRespDto queryStandardDataDetailComRespDto_2 = null;
    QueryStandardDataDetailComReqDto queryStandardDataDetailComReqDto_1=new QueryStandardDataDetailComReqDto();
  queryStandardDataDetailComReqDto_1.setDataType("PROGRESS_VALUE");//sourceId:2009395_1_72965
queryStandardDataDetailComReqDto_1.setResultType("MANUAL_INPUT");//sourceId:2009396_1_72965
queryStandardDataDetailComReqDto_1.setDataUsageSceneCode("TARGET_PLAN_CALC_DATA_STATISTICS");//sourceId:2009397_1_72965
queryStandardDataDetailComReqDto_1.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:2009401_1_72965
if(reqDto!=null){
      queryStandardDataDetailComReqDto_1.setPeriodId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:2009398_1_72965
queryStandardDataDetailComReqDto_1.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:2009400_1_72965
    }
if(circulationCollectionsRes!=null){
      queryStandardDataDetailComReqDto_1.setEntityId(circulationCollectionsRes.getEntityId());//SimpleFieldAssign//sourceId:2009399_1_72965
    }

    /*D4-1查进度值标准数据详情(公共)[2695]   */
    Assert.isNull(queryStandardDataDetailComReqDto_1.getPeriodId(),"D4执行刷人工填报数据（运维-临时）-D4-1查进度值标准数据详情(公共)-周期ID不能为空",false);
Assert.isNull(queryStandardDataDetailComReqDto_1.getDataType(),"D4执行刷人工填报数据（运维-临时）-D4-1查进度值标准数据详情(公共)-数据点类型不能为空",false);
Assert.isNull(queryStandardDataDetailComReqDto_1.getResultType(),"D4执行刷人工填报数据（运维-临时）-D4-1查进度值标准数据详情(公共)-结果产生类型不能为空",false);
Assert.isNull(queryStandardDataDetailComReqDto_1.getDataUsageSceneCode(),"D4执行刷人工填报数据（运维-临时）-D4-1查进度值标准数据详情(公共)-数据业务场景不能为空",false);
Assert.isNull(queryStandardDataDetailComReqDto_1.getEntityId(),"D4执行刷人工填报数据（运维-临时）-D4-1查进度值标准数据详情(公共)-归属内容表主键ID不能为空",false);
Assert.isNull(queryStandardDataDetailComReqDto_1.getThemeContentId(),"D4执行刷人工填报数据（运维-临时）-D4-1查进度值标准数据详情(公共)-主题内容ID不能为空",false);
Assert.isNull(queryStandardDataDetailComReqDto_1.getSubjectLifeCycle(),"D4执行刷人工填报数据（运维-临时）-D4-1查进度值标准数据详情(公共)-主体生命周期不能为空",false);
      queryStandardDataDetailComRespDto_2 = standardDataService.queryStandardDataDetailCom(queryStandardDataDetailComReqDto_1)/*vcase invoke isSameApp*/;



if((circulationCollectionsRes!= null&&  circulationCollectionsRes.getTargetValueType() !=null && circulationCollectionsRes.getTargetValueType().equals("NUMBER_GROWTH")||circulationCollectionsRes!= null&&  circulationCollectionsRes.getTargetValueType() !=null && circulationCollectionsRes.getTargetValueType().equals("NUMBER_DECLINE")) && queryStandardDataDetailComRespDto!=null && queryStandardDataDetailComRespDto.getDataResultId()!=null && queryStandardDataDetailComRespDto_2!=null && queryStandardDataDetailComRespDto_2.getDataResultId()!=null) {
        //if((M4执行目标归属周期【循环开始】.冗余指标业务类型 等于 数量增长型 or M4执行目标归属周期【循环开始】.冗余指标业务类型 等于 数量降幅型))  72966

QueryStandardDataDetailComRespDto queryStandardDataDetailComRespDto_4 = null;
    QueryStandardDataDetailComReqDto queryStandardDataDetailComReqDto_2=new QueryStandardDataDetailComReqDto();
  queryStandardDataDetailComReqDto_2.setDataType("PROGRESS_VALUE");//sourceId:2009395_1_72968
queryStandardDataDetailComReqDto_2.setResultType("MANUAL_INPUT");//sourceId:2009396_1_72968
queryStandardDataDetailComReqDto_2.setDataUsageSceneCode("TARGET_PLAN_CALC_DATA_STATISTICS");//sourceId:2009397_1_72968
queryStandardDataDetailComReqDto_2.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:2009401_1_72968
if(circulationCollectionsRes!=null){
      queryStandardDataDetailComReqDto_2.setPeriodId(circulationCollectionsRes.getPreviousCycleId());//SimpleFieldAssign//sourceId:2009398_1_72968
queryStandardDataDetailComReqDto_2.setEntityId(circulationCollectionsRes.getLastEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:2009399_1_72968
    }
if(reqDto!=null){
      queryStandardDataDetailComReqDto_2.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:2009400_1_72968
    }

    /*D4-1查进度值标准数据详情(公共)[2695]   */
    Assert.isNull(queryStandardDataDetailComReqDto_2.getPeriodId(),"D4执行刷人工填报数据（运维-临时）-D4-1查进度值标准数据详情(公共)-周期ID不能为空",false);
Assert.isNull(queryStandardDataDetailComReqDto_2.getDataType(),"D4执行刷人工填报数据（运维-临时）-D4-1查进度值标准数据详情(公共)-数据点类型不能为空",false);
Assert.isNull(queryStandardDataDetailComReqDto_2.getResultType(),"D4执行刷人工填报数据（运维-临时）-D4-1查进度值标准数据详情(公共)-结果产生类型不能为空",false);
Assert.isNull(queryStandardDataDetailComReqDto_2.getDataUsageSceneCode(),"D4执行刷人工填报数据（运维-临时）-D4-1查进度值标准数据详情(公共)-数据业务场景不能为空",false);
Assert.isNull(queryStandardDataDetailComReqDto_2.getEntityId(),"D4执行刷人工填报数据（运维-临时）-D4-1查进度值标准数据详情(公共)-归属内容表主键ID不能为空",false);
Assert.isNull(queryStandardDataDetailComReqDto_2.getThemeContentId(),"D4执行刷人工填报数据（运维-临时）-D4-1查进度值标准数据详情(公共)-主题内容ID不能为空",false);
Assert.isNull(queryStandardDataDetailComReqDto_2.getSubjectLifeCycle(),"D4执行刷人工填报数据（运维-临时）-D4-1查进度值标准数据详情(公共)-主体生命周期不能为空",false);
      queryStandardDataDetailComRespDto_4 = standardDataService.queryStandardDataDetailCom(queryStandardDataDetailComReqDto_2)/*vcase invoke isSameApp*/;



if((queryStandardDataDetailComRespDto_4!= null&& queryStandardDataDetailComRespDto_4.getDataResultId() != null )) {
        //if(D4-1查上一周期进度值标准数据详情(公共).数据结果ID  值不等于空 )  72977

        boolean bOOLEAN ;
        if(queryStandardDataDetailComRespDto_2 !=null&&queryStandardDataDetailComRespDto_4 !=null){
            OmsStandardDataResult omsStandardDataResult=new OmsStandardDataResult();
            if(queryStandardDataDetailComRespDto_2!=null){
      omsStandardDataResult.setDataResultId(queryStandardDataDetailComRespDto_2.getDataResultId());//SimpleFieldAssign//sourceId:2009404_1_72978
            }
            if(queryStandardDataDetailComRespDto_4!=null){
      omsStandardDataResult.setDataResult(queryStandardDataDetailComRespDto_4.getDataResult());//SimpleFieldAssign//sourceId:2009405_1_72978
            }
            if(receptionServiceRes!=null){
      omsStandardDataResult.setChangeFromLastValue(receptionServiceRes.getDataResult());//SimpleFieldAssign//sourceId:2009410_1_72978
omsStandardDataResult.setChangeFromLastRatio(receptionServiceRes.getDataResult());//SimpleFieldAssign//sourceId:2009411_1_72978
omsStandardDataResult.setUpdateCycleChangeFromLastValue(receptionServiceRes.getDataResult());//SimpleFieldAssign//sourceId:2009412_1_72978
omsStandardDataResult.setUpdateCycleChangeFromLastRatio(receptionServiceRes.getDataResult());//SimpleFieldAssign//sourceId:2009413_1_72978
            }

            /*4-01-01修改标准数据[2860]   */
            Assert.isNull(omsStandardDataResult.getDataResultId(),"D4执行刷人工填报数据（运维-临时）-4-01-01修改标准数据-数据结果ID 不能为空",false);
            Assert.isNull(omsStandardDataResult.getDataResult(),"D4执行刷人工填报数据（运维-临时）-4-01-01修改标准数据-数据值结果不能为空",false);
            bOOLEAN = mOmsStandardDataResultService.updateStandardData(omsStandardDataResult)/*vcase invoke 本地 method 方法调用;*/;



        }
        boolean bOOLEAN_1 ;
        if(queryStandardDataDetailComRespDto !=null){
            OmsStandardDataResult omsStandardDataResult_1=new OmsStandardDataResult();
            if(queryStandardDataDetailComRespDto!=null){
      omsStandardDataResult_1.setDataResultId(queryStandardDataDetailComRespDto.getDataResultId());//SimpleFieldAssign//sourceId:2009404_1_72979
            }
            if(receptionServiceRes!=null){
      omsStandardDataResult_1.setDataResult(receptionServiceRes.getDataResult());//SimpleFieldAssign//sourceId:2009405_1_72979
omsStandardDataResult_1.setChangeFromLastValue(receptionServiceRes.getDataResult());//SimpleFieldAssign//sourceId:2009410_1_72979
omsStandardDataResult_1.setChangeFromLastRatio(receptionServiceRes.getDataResult());//SimpleFieldAssign//sourceId:2009411_1_72979
omsStandardDataResult_1.setUpdateCycleChangeFromLastValue(receptionServiceRes.getDataResult());//SimpleFieldAssign//sourceId:2009412_1_72979
omsStandardDataResult_1.setUpdateCycleChangeFromLastRatio(receptionServiceRes.getDataResult());//SimpleFieldAssign//sourceId:2009413_1_72979
            }

            /*4-01-01修改标准数据[2860]   */
            Assert.isNull(omsStandardDataResult_1.getDataResultId(),"D4执行刷人工填报数据（运维-临时）-4-01-01修改标准数据-数据结果ID 不能为空",false);
            Assert.isNull(omsStandardDataResult_1.getDataResult(),"D4执行刷人工填报数据（运维-临时）-4-01-01修改标准数据-数据值结果不能为空",false);
            bOOLEAN_1 = mOmsStandardDataResultService.updateStandardData(omsStandardDataResult_1)/*vcase invoke 本地 method 方法调用;*/;



        }
    }


      }
else if((circulationCollectionsRes!= null&&  circulationCollectionsRes.getTargetValueType() !=null && circulationCollectionsRes.getTargetValueType().equals("PERCENTAGE_GROWTH")||circulationCollectionsRes!= null&&  circulationCollectionsRes.getTargetValueType() !=null && circulationCollectionsRes.getTargetValueType().equals("PERCENTAGE_DECLINE")||circulationCollectionsRes!= null&&  circulationCollectionsRes.getTargetValueType() !=null && circulationCollectionsRes.getTargetValueType().equals("PROGRESS")||circulationCollectionsRes!= null&&  circulationCollectionsRes.getTargetValueType() !=null && circulationCollectionsRes.getTargetValueType().equals("RATIO_GROWTH")||circulationCollectionsRes!= null&&  circulationCollectionsRes.getTargetValueType() !=null && circulationCollectionsRes.getTargetValueType().equals("RATIO_DECLINE")) && queryStandardDataDetailComRespDto!=null && queryStandardDataDetailComRespDto.getDataResultId()!=null && queryStandardDataDetailComRespDto_2!=null && queryStandardDataDetailComRespDto_2.getDataResultId()!=null){
       //elseif((M4执行目标归属周期【循环开始】.冗余指标业务类型 等于 百分比增长型 or M4执行目标归属周期【循环开始】.冗余指标业务类型 等于 百分比降幅型 or M4执行目标归属周期【循环开始】.冗余指标业务类型 等于 进度型 or M4执行目标归属周期【循环开始】.冗余指标业务类型 等于 比率增长型 or M4执行目标归属周期【循环开始】.冗余指标业务类型 等于 比率降幅型))  72972

QueryStandardDataDetailComRespDto queryStandardDataDetailComRespDto_5 = null;
    QueryStandardDataDetailComReqDto queryStandardDataDetailComReqDto_3=new QueryStandardDataDetailComReqDto();
  queryStandardDataDetailComReqDto_3.setDataType("ACTUAL_VALUE");//sourceId:2009387_1_72973
queryStandardDataDetailComReqDto_3.setResultType("MANUAL_INPUT");//sourceId:2009388_1_72973
queryStandardDataDetailComReqDto_3.setDataUsageSceneCode("TARGET_PLAN_CALC_DATA_STATISTICS");//sourceId:2009389_1_72973
queryStandardDataDetailComReqDto_3.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:2009393_1_72973
if(circulationCollectionsRes!=null){
      queryStandardDataDetailComReqDto_3.setPeriodId(circulationCollectionsRes.getPreviousCycleId());//SimpleFieldAssign//sourceId:2009390_1_72973
queryStandardDataDetailComReqDto_3.setEntityId(circulationCollectionsRes.getLastEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:2009391_1_72973
    }
if(reqDto!=null){
      queryStandardDataDetailComReqDto_3.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:2009392_1_72973
    }

    /*D4-1查实际值标准数据详情(公共)[2695]   */
    Assert.isNull(queryStandardDataDetailComReqDto_3.getPeriodId(),"D4执行刷人工填报数据（运维-临时）-D4-1查实际值标准数据详情(公共)-周期ID不能为空",false);
Assert.isNull(queryStandardDataDetailComReqDto_3.getDataType(),"D4执行刷人工填报数据（运维-临时）-D4-1查实际值标准数据详情(公共)-数据点类型不能为空",false);
Assert.isNull(queryStandardDataDetailComReqDto_3.getResultType(),"D4执行刷人工填报数据（运维-临时）-D4-1查实际值标准数据详情(公共)-结果产生类型不能为空",false);
Assert.isNull(queryStandardDataDetailComReqDto_3.getDataUsageSceneCode(),"D4执行刷人工填报数据（运维-临时）-D4-1查实际值标准数据详情(公共)-数据业务场景不能为空",false);
Assert.isNull(queryStandardDataDetailComReqDto_3.getEntityId(),"D4执行刷人工填报数据（运维-临时）-D4-1查实际值标准数据详情(公共)-归属内容表主键ID不能为空",false);
Assert.isNull(queryStandardDataDetailComReqDto_3.getThemeContentId(),"D4执行刷人工填报数据（运维-临时）-D4-1查实际值标准数据详情(公共)-主题内容ID不能为空",false);
Assert.isNull(queryStandardDataDetailComReqDto_3.getSubjectLifeCycle(),"D4执行刷人工填报数据（运维-临时）-D4-1查实际值标准数据详情(公共)-主体生命周期不能为空",false);
      queryStandardDataDetailComRespDto_5 = standardDataService.queryStandardDataDetailCom(queryStandardDataDetailComReqDto_3)/*vcase invoke isSameApp*/;



if((queryStandardDataDetailComRespDto_5!= null&& queryStandardDataDetailComRespDto_5.getDataResultId() != null )) {
        //if(D4-1查上一周期实际值(公共).数据结果ID  值不等于空 )  72980

    boolean bOOLEAN_2 ;
    if(queryStandardDataDetailComRespDto !=null&&queryStandardDataDetailComRespDto_5 !=null){
        OmsStandardDataResult omsStandardDataResult_2=new OmsStandardDataResult();
        if(queryStandardDataDetailComRespDto!=null){
      omsStandardDataResult_2.setDataResultId(queryStandardDataDetailComRespDto.getDataResultId());//SimpleFieldAssign//sourceId:2009404_1_72981
        }
        if(queryStandardDataDetailComRespDto_5!=null){
      omsStandardDataResult_2.setDataResult(queryStandardDataDetailComRespDto_5.getDataResult());//SimpleFieldAssign//sourceId:2009405_1_72981
        }
        if(receptionServiceRes!=null){
      omsStandardDataResult_2.setChangeFromLastValue(receptionServiceRes.getDataResult());//SimpleFieldAssign//sourceId:2009410_1_72981
omsStandardDataResult_2.setChangeFromLastRatio(receptionServiceRes.getDataResult());//SimpleFieldAssign//sourceId:2009411_1_72981
omsStandardDataResult_2.setUpdateCycleChangeFromLastValue(receptionServiceRes.getDataResult());//SimpleFieldAssign//sourceId:2009412_1_72981
omsStandardDataResult_2.setUpdateCycleChangeFromLastRatio(receptionServiceRes.getDataResult());//SimpleFieldAssign//sourceId:2009413_1_72981
        }

        /*4-01-01修改标准数据[2860]   */
        Assert.isNull(omsStandardDataResult_2.getDataResultId(),"D4执行刷人工填报数据（运维-临时）-4-01-01修改标准数据-数据结果ID 不能为空",false);
        Assert.isNull(omsStandardDataResult_2.getDataResult(),"D4执行刷人工填报数据（运维-临时）-4-01-01修改标准数据-数据值结果不能为空",false);
        bOOLEAN_2 = mOmsStandardDataResultService.updateStandardData(omsStandardDataResult_2)/*vcase invoke 本地 method 方法调用;*/;



    }
}


QueryStandardDataDetailComRespDto queryStandardDataDetailComRespDto_6 = null;
    QueryStandardDataDetailComReqDto queryStandardDataDetailComReqDto_4=new QueryStandardDataDetailComReqDto();
  queryStandardDataDetailComReqDto_4.setDataType("PROGRESS_VALUE");//sourceId:2009395_1_72975
queryStandardDataDetailComReqDto_4.setResultType("MANUAL_INPUT");//sourceId:2009396_1_72975
queryStandardDataDetailComReqDto_4.setDataUsageSceneCode("TARGET_PLAN_CALC_DATA_STATISTICS");//sourceId:2009397_1_72975
queryStandardDataDetailComReqDto_4.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:2009401_1_72975
if(circulationCollectionsRes!=null){
      queryStandardDataDetailComReqDto_4.setPeriodId(circulationCollectionsRes.getPreviousCycleId());//SimpleFieldAssign//sourceId:2009398_1_72975
queryStandardDataDetailComReqDto_4.setEntityId(circulationCollectionsRes.getLastEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:2009399_1_72975
    }
if(reqDto!=null){
      queryStandardDataDetailComReqDto_4.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:2009400_1_72975
    }

    /*D4-1查进度值标准数据详情(公共)[2695]   */
    Assert.isNull(queryStandardDataDetailComReqDto_4.getPeriodId(),"D4执行刷人工填报数据（运维-临时）-D4-1查进度值标准数据详情(公共)-周期ID不能为空",false);
Assert.isNull(queryStandardDataDetailComReqDto_4.getDataType(),"D4执行刷人工填报数据（运维-临时）-D4-1查进度值标准数据详情(公共)-数据点类型不能为空",false);
Assert.isNull(queryStandardDataDetailComReqDto_4.getResultType(),"D4执行刷人工填报数据（运维-临时）-D4-1查进度值标准数据详情(公共)-结果产生类型不能为空",false);
Assert.isNull(queryStandardDataDetailComReqDto_4.getDataUsageSceneCode(),"D4执行刷人工填报数据（运维-临时）-D4-1查进度值标准数据详情(公共)-数据业务场景不能为空",false);
Assert.isNull(queryStandardDataDetailComReqDto_4.getEntityId(),"D4执行刷人工填报数据（运维-临时）-D4-1查进度值标准数据详情(公共)-归属内容表主键ID不能为空",false);
Assert.isNull(queryStandardDataDetailComReqDto_4.getThemeContentId(),"D4执行刷人工填报数据（运维-临时）-D4-1查进度值标准数据详情(公共)-主题内容ID不能为空",false);
Assert.isNull(queryStandardDataDetailComReqDto_4.getSubjectLifeCycle(),"D4执行刷人工填报数据（运维-临时）-D4-1查进度值标准数据详情(公共)-主体生命周期不能为空",false);
      queryStandardDataDetailComRespDto_6 = standardDataService.queryStandardDataDetailCom(queryStandardDataDetailComReqDto_4)/*vcase invoke isSameApp*/;



if((queryStandardDataDetailComRespDto_6!= null&& queryStandardDataDetailComRespDto_6.getDataResultId() != null )) {
        //if(D4-1查上一周期进度值(公共).数据结果ID  值不等于空 )  72982

          boolean bOOLEAN_3 ;
          if(queryStandardDataDetailComRespDto_2 !=null&&queryStandardDataDetailComRespDto_6 !=null){
              OmsStandardDataResult omsStandardDataResult_3=new OmsStandardDataResult();
              if(queryStandardDataDetailComRespDto_2!=null){
      omsStandardDataResult_3.setDataResultId(queryStandardDataDetailComRespDto_2.getDataResultId());//SimpleFieldAssign//sourceId:2009404_1_72983
              }
              if(queryStandardDataDetailComRespDto_6!=null){
      omsStandardDataResult_3.setDataResult(queryStandardDataDetailComRespDto_6.getDataResult());//SimpleFieldAssign//sourceId:2009405_1_72983
              }
              if(receptionServiceRes!=null){
      omsStandardDataResult_3.setChangeFromLastValue(receptionServiceRes.getDataResult());//SimpleFieldAssign//sourceId:2009410_1_72983
omsStandardDataResult_3.setChangeFromLastRatio(receptionServiceRes.getDataResult());//SimpleFieldAssign//sourceId:2009411_1_72983
omsStandardDataResult_3.setUpdateCycleChangeFromLastValue(receptionServiceRes.getDataResult());//SimpleFieldAssign//sourceId:2009412_1_72983
omsStandardDataResult_3.setUpdateCycleChangeFromLastRatio(receptionServiceRes.getDataResult());//SimpleFieldAssign//sourceId:2009413_1_72983
              }

              /*4-01-01修改标准数据[2860]   */
              Assert.isNull(omsStandardDataResult_3.getDataResultId(),"D4执行刷人工填报数据（运维-临时）-4-01-01修改标准数据-数据结果ID 不能为空",false);
              Assert.isNull(omsStandardDataResult_3.getDataResult(),"D4执行刷人工填报数据（运维-临时）-4-01-01修改标准数据-数据值结果不能为空",false);
              bOOLEAN_3 = mOmsStandardDataResultService.updateStandardData(omsStandardDataResult_3)/*vcase invoke 本地 method 方法调用;*/;



          }
      }



    }
//ModelCode: circulationEnd
        }

      }
ImplementBrushManualFullDataRespDto retData = new ImplementBrushManualFullDataRespDto();





return retData;
  }

    //
}
